From 15ee49f42eb43bd833b59536c68a99fa0de36166 Mon Sep 17 00:00:00 2001 From: Aadhavan Srinivasan Date: Sun, 9 Feb 2025 15:51:46 -0500 Subject: [PATCH] Rename method receivers from 'regex' to 're' (it's shorter) --- regex/compile.go | 12 ++++++------ regex/matching.go | 44 ++++++++++++++++++++++---------------------- 2 files changed, 28 insertions(+), 28 deletions(-) diff --git a/regex/compile.go b/regex/compile.go index da733de..d9bef70 100644 --- a/regex/compile.go +++ b/regex/compile.go @@ -22,17 +22,17 @@ type Reg struct { // NumSubexp returns the number of sub-expressions in the given [Reg]. This is equivalent // to the number of capturing groups. -func (r Reg) NumSubexp() int { - return r.numGroups +func (re Reg) NumSubexp() int { + return re.numGroups } // String returns the string used to compile the expression. -func (r Reg) String() string { - return r.str +func (re Reg) String() string { + return re.str } -func (r Reg) Longest() { - r.preferLongest = true +func (re *Reg) Longest() { + re.preferLongest = true } const concatRune rune = 0xF0001 diff --git a/regex/matching.go b/regex/matching.go index 0787572..4d6b4e3 100644 --- a/regex/matching.go +++ b/regex/matching.go @@ -65,8 +65,8 @@ func copyThread(to *nfaState, from nfaState) { // Find returns the 0-group of the leftmost match of the regex in the given string. // An error value != nil indicates that no match was found. -func (regex Reg) Find(str string) (Group, error) { - match, err := regex.FindNthMatch(str, 1) +func (re Reg) Find(str string) (Group, error) { + match, err := re.FindNthMatch(str, 1) if err != nil { return Group{}, fmt.Errorf("no matches found") } @@ -74,8 +74,8 @@ func (regex Reg) Find(str string) (Group, error) { } // Match returns a boolean value, indicating whether the regex found a match in the given string. -func (regex Reg) Match(str string) bool { - _, err := regex.Find(str) +func (re Reg) Match(str string) bool { + _, err := re.Find(str) return err == nil } @@ -93,8 +93,8 @@ func CompileMatch(expr string, str string, flags ...ReFlag) (bool, error) { // FindAll returns a slice containing all the 0-groups of the regex in the given string. // A 0-group represents the match without any submatches. -func (regex Reg) FindAll(str string) []Group { - indices := regex.FindAllSubmatch(str) +func (re Reg) FindAll(str string) []Group { + indices := re.FindAllSubmatch(str) zeroGroups := funcMap(indices, getZeroGroup) return zeroGroups } @@ -103,8 +103,8 @@ func (regex Reg) FindAll(str string) []Group { // The return value will be an empty string in two situations: // 1. No match was found // 2. The match was an empty string -func (regex Reg) FindString(str string) string { - match, err := regex.FindNthMatch(str, 1) +func (re Reg) FindString(str string) string { + match, err := re.FindNthMatch(str, 1) if err != nil { return "" } @@ -117,8 +117,8 @@ func (regex Reg) FindString(str string) string { // number of groups. The validity of a group (whether or not it matched anything) can be determined with // [Group.IsValid], or by checking that both indices of the group are >= 0. // The second-return value is nil if no match was found. -func (regex Reg) FindSubmatch(str string) (Match, error) { - match, err := regex.FindNthMatch(str, 1) +func (re Reg) FindSubmatch(str string) (Match, error) { + match, err := re.FindNthMatch(str, 1) if err != nil { return Match{}, fmt.Errorf("no match found") } else { @@ -135,9 +135,9 @@ func (regex Reg) FindSubmatch(str string) (Match, error) { // 2. Group n found a zero-length match // // A return value of nil indicates no match. -func (regex Reg) FindStringSubmatch(str string) []string { - matchStr := make([]string, regex.numGroups+1) - match, err := regex.FindSubmatch(str) +func (re Reg) FindStringSubmatch(str string) []string { + matchStr := make([]string, re.numGroups+1) + match, err := re.FindSubmatch(str) if err != nil { return nil } @@ -159,8 +159,8 @@ func (regex Reg) FindStringSubmatch(str string) []string { // FindAllString is the 'all' version of [FindString]. // It returns a slice of strings containing the text of all matches of // the regex in the given string. -func (regex Reg) FindAllString(str string) []string { - zerogroups := regex.FindAll(str) +func (re Reg) FindAllString(str string) []string { + zerogroups := re.FindAll(str) matchStrs := funcMap(zerogroups, func(g Group) string { return str[g.StartIdx:g.EndIdx] }) @@ -169,14 +169,14 @@ func (regex Reg) FindAllString(str string) []string { // FindNthMatch return the 'n'th match of the regex in the given string. // It returns an error (!= nil) if there are fewer than 'n' matches in the string. -func (regex Reg) FindNthMatch(str string, n int) (Match, error) { +func (re Reg) FindNthMatch(str string, n int) (Match, error) { idx := 0 matchNum := 0 str_runes := []rune(str) var matchFound bool var matchIdx Match for idx <= len(str_runes) { - matchFound, matchIdx, idx = findAllSubmatchHelper(regex.start, str_runes, idx, regex.numGroups, regex.preferLongest) + matchFound, matchIdx, idx = findAllSubmatchHelper(re.start, str_runes, idx, re.numGroups, re.preferLongest) if matchFound { matchNum++ } @@ -189,14 +189,14 @@ func (regex Reg) FindNthMatch(str string, n int) (Match, error) { } // FindAllSubmatch returns a slice of matches in the given string. -func (regex Reg) FindAllSubmatch(str string) []Match { +func (re Reg) FindAllSubmatch(str string) []Match { idx := 0 str_runes := []rune(str) var matchFound bool var matchIdx Match indices := make([]Match, 0) for idx <= len(str_runes) { - matchFound, matchIdx, idx = findAllSubmatchHelper(regex.start, str_runes, idx, regex.numGroups, regex.preferLongest) + matchFound, matchIdx, idx = findAllSubmatchHelper(re.start, str_runes, idx, re.numGroups, re.preferLongest) if matchFound { indices = append(indices, matchIdx) } @@ -313,7 +313,7 @@ func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups in // A variable is of the form '$n', where 'n' is a number. It will be replaced by the contents of the n-th capturing group. // To insert a literal $, do not put a number after it. Alternatively, you can use $$. // src is the input string, and match must be the result of [Reg.FindSubmatch]. -func (regex Reg) Expand(dst string, template string, src string, match Match) string { +func (re Reg) Expand(dst string, template string, src string, match Match) string { templateRuneSlc := []rune(template) srcRuneSlc := []rune(src) i := 0 @@ -352,8 +352,8 @@ func (regex Reg) Expand(dst string, template string, src string, match Match) st // LiteralPrefix returns a string that must begin any match of the given regular expression. // The second return value is true if the string comprises the entire expression. -func (regex Reg) LiteralPrefix() (prefix string, complete bool) { - state := regex.start +func (re Reg) LiteralPrefix() (prefix string, complete bool) { + state := re.start if state.assert != noneAssert { state = state.next }