refactor: Rename some methods and types related to ByRegex. (#86)

I think "regexMatch" makes more sense than "regexToken" because we
aren't doing anything special to the raw regex match.

I like "regexDidNotMatch" better than "alwaysLast" since the former
actually describes how we get that value instead of the business logic
implications.

Author: JeffFaer

keepsorted/block.go

@@ -403,8 +403,8 @@ func (b block) lessFn() cmpFunc[lineGroup] {
 		return 1
 	})
 
-	regexTransform := func(lg lineGroup) []regexToken {
-		return b.metadata.opts.regexTransform(lg.joinedLines())
+	regexTransform := func(lg lineGroup) []regexMatch {
+		return b.metadata.opts.matchRegexes(lg.joinedLines())
 	}
 
 	ord := newPrefixOrder(b.metadata.opts)
@@ -442,6 +442,6 @@ func (b block) lessFn() cmpFunc[lineGroup] {
 	}, numericTokens.compare)
 
 	return commentOnlyBlock.
-		andThen(comparingFunc(regexTransform, compareRegexTokens(prefixOrder.andThen(lexicographically(transformOrder))))).
+		andThen(comparingFunc(regexTransform, compareRegexMatches(prefixOrder.andThen(lexicographically(transformOrder))))).
 		andThen(lineGroup.less)
 }

keepsorted/options.go

@@ -375,23 +375,23 @@ func (opts blockOptions) trimIgnorePrefix(s string) string {
 	return s
 }
 
-// regexTransform applies ByRegex to s.
+// matchRegexes applies ByRegex to s.
 // If ByRegex is empty, returns a slice that contains just s.
 // Otherwise, applies each regex to s in sequence:
 // If a regex has capturing groups, the capturing groups will be added to the
 // resulting slice.
 // If a regex does not have capturing groups, all matched text will be added to
 // the resulting slice.
-func (opts blockOptions) regexTransform(s string) []regexToken {
+func (opts blockOptions) matchRegexes(s string) []regexMatch {
 	if len(opts.ByRegex) == 0 {
-		return []regexToken{{s}}
+		return []regexMatch{{s}}
 	}
 
-	var ret []regexToken
+	var ret []regexMatch
 	for _, regex := range opts.ByRegex {
 		m := regex.FindStringSubmatch(s)
 		if m == nil {
-			ret = append(ret, alwaysLast)
+			ret = append(ret, regexDidNotMatch)
 			continue
 		}
 		if len(m) == 1 {
@@ -405,19 +405,19 @@ func (opts blockOptions) regexTransform(s string) []regexToken {
 	return ret
 }
 
-// regexToken is the result of matching a regex to a string. It has 3 forms:
+// regexMatch is the result of matching a regex to a string. It has 3 forms:
 //  1. If the regex matched and the regex had capturing groups, it's the value
 //     of those capturing groups.
 //  2. If the regex matched and the regex didn't have capturing groups, it's the
 //     value of the matched string as a singleton slice.
-//  3. IF the regex didn't match, it's alwaysLast / nil.
-type regexToken []string
+//  3. If the regex didn't match, it's regexDidNotMatch / nil.
+type regexMatch []string
 
-var alwaysLast regexToken = nil
+var regexDidNotMatch regexMatch = nil
 
-func compareRegexTokens(fn cmpFunc[[]string]) cmpFunc[[]regexToken] {
-	alwaysLast := comparingFunc(func(t regexToken) bool { return t == nil }, falseFirst())
-	delegate := comparingFunc(func(t regexToken) []string { return []string(t) }, fn)
+func compareRegexMatches(fn cmpFunc[[]string]) cmpFunc[[]regexMatch] {
+	alwaysLast := comparingFunc(func(t regexMatch) bool { return t == nil }, falseFirst())
+	delegate := comparingFunc(func(t regexMatch) []string { return t }, fn)
 	return lexicographically(alwaysLast.andThen(delegate))
 }
 

keepsorted/options_test.go

@@ -312,13 +312,13 @@ func TestBlockOptions_regexTransform(t *testing.T) {
 				opts.ByRegex = append(opts.ByRegex, regexp.MustCompile(regex))
 			}
 
-			gotTokens := opts.regexTransform(tc.in)
+			gotTokens := opts.matchRegexes(tc.in)
 			got := make([][]string, len(gotTokens))
 			for i, t := range gotTokens {
 				got[i] = []string(t)
 			}
 			if diff := cmp.Diff(tc.want, got); diff != "" {
-				t.Errorf("%q.regexTransform(%q) diff (-want +got)\n%s", opts, tc.in, diff)
+				t.Errorf("%q.matchRegexes(%q) diff (-want +got)\n%s", opts, tc.in, diff)
 			}
 		})
 	}