rename some funcs and vars on char classes

lib/charclass.go

@@ -12,16 +12,16 @@ type charClassGenerator struct {
 }
 
 func (g *charClassGenerator) Generate(s *State) error {
-	for _, charset := range g.charClasses {
-		if len(charset) == 0 {
+	for _, chars := range g.charClasses {
+		if len(chars) == 0 {
 			continue
 		}
-		ibig, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
+		ibig, err := rand.Int(rand.Reader, big.NewInt(int64(len(chars))))
 		if err != nil {
 			panic(err)
 		}
 		i := int(ibig.Int64())
-		s.output = append(s.output, charset[i])
+		s.output = append(s.output, chars[i])
 	}
 	entropy, err := g.Entropy(s)
 	if err != nil {
@@ -36,11 +36,11 @@ func (g *charClassGenerator) Entropy(s *State) (float64, error) {
 		return *g.entropy, nil
 	}
 	entropy := 0.0
-	for _, charset := range g.charClasses {
-		if len(charset) == 0 {
+	for _, chars := range g.charClasses {
+		if len(chars) == 0 {
 			continue
 		}
-		entropy += math.Log2(float64(len(charset)))
+		entropy += math.Log2(float64(len(chars)))
 	}
 	g.entropy = &entropy
 	return entropy, nil

lib/lex.go

@@ -93,9 +93,9 @@ func lexBackslash(s *State) (LexType, error) {
 		}
 		return lexRootUnicodeWide, nil
 	case 'd':
-		return processRange(s, []rune("0123456789"))
+		return processCharClass(s, []rune("0123456789"))
 	case 'w':
-		return processRange(s, wordChars)
+		return processCharClass(s, wordChars)
 	}
 	err := s.addOutputOne(backslashEscape(c))
 	if err != nil {

lib/lex_charclass.go

@@ -1,15 +1,15 @@
 package passgen
 
-func processRange(s *State, charset []rune) (LexType, error) {
+func processCharClass(s *State, chars []rune) (LexType, error) {
 	reverse := s.rangeReverse
 	s.openBracket = false
 	s.rangeReverse = false
-	charset = removeDuplicateRunes(charset)
+	chars = removeDuplicateRunes(chars)
 	if reverse {
-		charset = excludeCharsASCII(charset)
+		chars = excludeCharsASCII(chars)
 	}
 	gen := &charClassGenerator{
-		charClasses: [][]rune{charset},
+		charClasses: [][]rune{chars},
 	}
 	err := gen.Generate(s)
 	if err != nil {
@@ -42,7 +42,7 @@ func lexRange(s *State) (LexType, error) {
 			return lexRange, nil
 		}
 	case ']':
-		return processRange(s, s.buffer)
+		return processCharClass(s, s.buffer)
 	}
 	s.buffer = append(s.buffer, c)
 	return lexRange, nil
@@ -60,12 +60,12 @@ func lexRangeColon(s *State) (LexType, error) {
 		switch c {
 		case ':':
 			name := string(nameRunes)
-			charset, ok := charClasses[name]
+			chars, ok := charClasses[name]
 			if !ok {
 				s.errorMarkLen = len(name) + 2
 				return nil, s.errorValue("invalid character class %#v", name)
 			}
-			s.buffer = append(s.buffer, charset...)
+			s.buffer = append(s.buffer, chars...)
 			return lexRange, nil
 		case ']':
 			s.errorMarkLen = len(nameRunes) + 2

lib/utils.go

@@ -1,16 +1,16 @@
 package passgen
 
-func removeDuplicateRunes(list []rune) []rune {
+func removeDuplicateRunes(chars []rune) []rune {
 	set := map[rune]bool{}
-	newlist := make([]rune, 0, len(list))
-	for _, c := range list {
+	newChars := make([]rune, 0, len(chars))
+	for _, c := range chars {
 		if set[c] {
 			continue
 		}
 		set[c] = true
-		newlist = append(newlist, c)
+		newChars = append(newChars, c)
 	}
-	return newlist
+	return newChars
 }
 
 func byteRange(start uint, end uint) []rune {