feat(regex): expose findP

src/regex/regex.go

@@ -3,6 +3,8 @@ package regex
 import (
 	"regexp"
 	"sync"
+
+	"github.com/jandedobbeleer/oh-my-posh/src/log"
 )
 
 var (
@@ -14,50 +16,67 @@ const (
 	LINK = `(?P<STR>\x1b]8;;(.+)\x1b\\(?P<TEXT>.+)\x1b]8;;\x1b\\)`
 )
 
-func GetCompiledRegex(pattern string) *regexp.Regexp {
+func GetCompiledRegex(pattern string) (*regexp.Regexp, error) {
 	// try in cache first
 	regexCacheLock.RLock()
 	re := regexCache[pattern]
 	regexCacheLock.RUnlock()
 	if re != nil {
-		return re
+		return re, nil
 	}
 
 	// should we panic or return the error?
-	re = regexp.MustCompile(pattern)
+	re, err := regexp.Compile(pattern)
+	if err != nil {
+		log.Error(err)
+		return nil, err
+	}
 
 	// lock for concurrent access and save the compiled expression in cache
 	regexCacheLock.Lock()
 	regexCache[pattern] = re
 	regexCacheLock.Unlock()
 
-	return re
+	return re, nil
 }
 
 func FindNamedRegexMatch(pattern, text string) map[string]string {
-	// error ignored because mustCompile will cause a panic
-	re := GetCompiledRegex(pattern)
-	match := re.FindStringSubmatch(text)
 	result := make(map[string]string)
+
+	re, err := GetCompiledRegex(pattern)
+	if err != nil {
+		return result
+	}
+
+	match := re.FindStringSubmatch(text)
 	if len(match) == 0 {
 		return result
 	}
+
 	for i, name := range re.SubexpNames() {
 		if i == 0 {
 			continue
 		}
 		result[name] = match[i]
 	}
+
 	return result
 }
 
 func FindAllNamedRegexMatch(pattern, text string) []map[string]string {
-	re := GetCompiledRegex(pattern)
-	match := re.FindAllStringSubmatch(text, -1)
 	var results []map[string]string
+
+	re, err := GetCompiledRegex(pattern)
+	if err != nil {
+		return results
+	}
+
+	match := re.FindAllStringSubmatch(text, -1)
+
 	if len(match) == 0 {
 		return results
 	}
+
 	for _, set := range match {
 		result := make(map[string]string)
 		for i, name := range re.SubexpNames() {
@@ -69,15 +88,43 @@ func FindAllNamedRegexMatch(pattern, text string) []map[string]string {
 		}
 		results = append(results, result)
 	}
+
 	return results
 }
 
 func ReplaceAllString(pattern, text, replaceText string) string {
-	re := GetCompiledRegex(pattern)
+	re, err := GetCompiledRegex(pattern)
+	if err != nil {
+		return text
+	}
+
 	return re.ReplaceAllString(text, replaceText)
 }
 
 func MatchString(pattern, text string) bool {
-	re := GetCompiledRegex(pattern)
+	re, err := GetCompiledRegex(pattern)
+	if err != nil {
+		return false
+	}
+
 	return re.MatchString(text)
 }
+
+func FindStringMatch(pattern, text string, index int) string {
+	re, err := GetCompiledRegex(pattern)
+	if err != nil {
+		return text
+	}
+
+	matches := re.FindStringSubmatch(text)
+	if len(matches) <= index {
+		return text
+	}
+
+	match := matches[index]
+	if len(match) == 0 {
+		return text
+	}
+
+	return match
+}

src/regex/regex_test.go

@@ -0,0 +1,72 @@
+package regex
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFindStringMatch(t *testing.T) {
+	cases := []struct {
+		Case     string
+		Pattern  string
+		Text     string
+		Index    int
+		Expected string
+	}{
+		{
+			Case:     "Full match at index 0",
+			Pattern:  `\w+`,
+			Text:     "hello",
+			Index:    0,
+			Expected: "hello",
+		},
+		{
+			Case:     "Capture group at index 1",
+			Pattern:  `hello (\w+)`,
+			Text:     "hello world",
+			Index:    1,
+			Expected: "world",
+		},
+		{
+			Case:     "No matches returns original text",
+			Pattern:  `\d+`,
+			Text:     "hello",
+			Index:    0,
+			Expected: "hello",
+		},
+		{
+			Case:     "Invalid pattern returns original text",
+			Pattern:  `[invalid`,
+			Text:     "hello",
+			Index:    0,
+			Expected: "hello",
+		},
+		{
+			Case:     "Empty text returns empty string",
+			Pattern:  `\w+`,
+			Text:     "",
+			Index:    0,
+			Expected: "",
+		},
+		{
+			Case:     "Index out of bounds returns original text",
+			Pattern:  `(\w+)`,
+			Text:     "hello",
+			Index:    2,
+			Expected: "hello",
+		},
+		{
+			Case:     "Multiple capture groups",
+			Pattern:  `(\w+)\s(\w+)`,
+			Text:     "hello world",
+			Index:    2,
+			Expected: "world",
+		},
+	}
+
+	for _, tc := range cases {
+		got := FindStringMatch(tc.Pattern, tc.Text, tc.Index)
+		assert.Equal(t, tc.Expected, got, tc.Case)
+	}
+}

src/runtime/path/clean.go

@@ -75,8 +75,10 @@ func Clean(input string) string {
 		}
 
 		// Always use an uppercase drive letter on Windows.
-		driveLetter := regex.GetCompiledRegex(`^[a-z]:`)
-		cleaned = driveLetter.ReplaceAllStringFunc(cleaned, strings.ToUpper)
+		driveLetter, err := regex.GetCompiledRegex(`^[a-z]:`)
+		if err == nil {
+			cleaned = driveLetter.ReplaceAllStringFunc(cleaned, strings.ToUpper)
+		}
 	}
 
 	sb := new(strings.Builder)

src/runtime/terminal.go

@@ -89,9 +89,14 @@ func (term *Terminal) setPwd() {
 		if term.GOOS() != WINDOWS {
 			return pwd
 		}
+
 		// on Windows, and being case sensitive and not consistent and all, this gives silly issues
-		driveLetter := regex.GetCompiledRegex(`^[a-z]:`)
-		return driveLetter.ReplaceAllStringFunc(pwd, strings.ToUpper)
+		driveLetter, err := regex.GetCompiledRegex(`^[a-z]:`)
+		if err == nil {
+			return driveLetter.ReplaceAllStringFunc(pwd, strings.ToUpper)
+		}
+
+		return pwd
 	}
 
 	if term.CmdFlags != nil && term.CmdFlags.PWD != "" {

src/segments/scm.go

@@ -116,7 +116,7 @@ func (s *scm) formatBranch(branch string) string {
 	}
 
 	branchTemplate := s.props.GetString(BranchTemplate, "")
-	if branchTemplate == "" {
+	if len(branchTemplate) == 0 {
 		return branch
 	}
 

src/template/func_map.go

@@ -14,6 +14,7 @@ func funcMap() template.FuncMap {
 		"path":         filePath,
 		"glob":         glob,
 		"matchP":       matchP,
+		"findP":        findP,
 		"replaceP":     replaceP,
 		"gt":           gt,
 		"lt":           lt,

src/template/regex.go

@@ -9,3 +9,7 @@ func matchP(pattern, text string) bool {
 func replaceP(pattern, text, replaceText string) string {
 	return regex.ReplaceAllString(pattern, text, replaceText)
 }
+
+func findP(pattern, text string, index int) string {
+	return regex.FindStringMatch(pattern, text, index)
+}