From 037ac75ea69e407724e780dc69eb245d3ddc027d Mon Sep 17 00:00:00 2001
From: Aadhavan Srinivasan <aadhavan@twomorecents.org>
Date: Fri, 31 Jan 2025 10:12:53 -0500
Subject: [PATCH] Wrote new method to return 0-group of leftmost match;
reorganized some functions for better clarity; made 'FindNthMatch' a method
---
regex/matching.go | 52 +++++++++++++++++++++++++++++++----------------
1 file changed, 34 insertions(+), 18 deletions(-)
diff --git a/regex/matching.go b/regex/matching.go
index 66fcfd8..fd17ea7 100644
--- a/regex/matching.go
+++ b/regex/matching.go
@@ -57,6 +57,11 @@ func (g Group) isValid() bool {
return g.StartIdx >= 0 && g.EndIdx >= 0
}
+// Simple function, makes it easier to map this over a list of matches
+func getZeroGroup(m Match) Group {
+ return m[0]
+}
+
// takeZeroState takes the 0-state (if such a transition exists) for all states in the
// given slice. It returns the resulting states. If any of the resulting states is a 0-state,
// the second ret val is true.
@@ -138,30 +143,51 @@ func pruneIndices(indices []Match) []Match {
return toRet
}
-// FindString returns a string containing the text of the leftmost match of the regex in the given string.
+// 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)
+ if err != nil {
+ return Group{}, nil
+ }
+ return getZeroGroup(match), nil
+}
+
+// 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)
+ zeroGroups := funcMap(indices, getZeroGroup)
+ return zeroGroups
+}
+
+// FindString returns the text of the leftmost match of the regex in the given string.
// 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 := FindNthMatch(regex, str, 1)
+ match, err := regex.FindNthMatch(str, 1)
if err != nil {
return ""
}
- return str[match[0].StartIdx:match[0].EndIdx]
+ zeroGroup := getZeroGroup(match)
+ return str[zeroGroup.StartIdx:zeroGroup.EndIdx]
}
// 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 {
- return []string{}
- // matches := FindAllMatches, str string)
+ zerogroups := regex.FindAll(str)
+ matchStrs := funcMap(zerogroups, func(g Group) string {
+ return str[g.StartIdx:g.EndIdx]
+ })
+ return matchStrs
}
-// FindNthMatch finds the 'n'th match of the regex represented by the given start-state, with
-// the given 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 FindNthMatch(regex Reg, str string, n int) (Match, error) {
+func (regex Reg) FindNthMatch(str string, n int) (Match, error) {
idx := 0
matchNum := 0
str_runes := []rune(str)
@@ -180,16 +206,6 @@ func FindNthMatch(regex Reg, str string, n int) (Match, error) {
return nil, fmt.Errorf("invalid match index - too few matches found")
}
-// 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)
- zeroGroups := funcMap(indices, func(m Match) Group {
- return m[0]
- })
- return zeroGroups
-}
-
// FindAllSubmatch returns a slice of matches in the given string.
func (regex Reg) FindAllSubmatch(str string) []Match {
idx := 0