fix(lite): fix glob cache key mutation, use QuoteMeta, and share single regex cache (minekube#675)

* fix(lite): simplify matchWithGroups and add cache/escaping tests

Build on minekube#669: unify matchWithGroups to use regexp.QuoteMeta (same
approach as the cache loader) instead of manual character-by-character
escaping that missed some regex metacharacters. Add dedicated tests
for cache consistency on repeated lookups and literal dot escaping.

* fix(lite): cache matchWithGroups regex and add comprehensive tests

- Cache compiled regexes in matchWithGroups via a separate ttlcache
  (same pattern as match), avoiding recompilation on every call
- Simplify matchWithGroups to use regexp.QuoteMeta instead of manual
  character-by-character escaping that missed some metacharacters
- Add cache consistency tests for both match and matchWithGroups
- Add literal dot escaping tests to prevent regex wildcard regression
- Add BenchmarkMatchWithGroups

* refactor(lite): consolidate to single shared regex cache

Both match and matchWithGroups now share one cache via getRegexp.
With anchored patterns (^...$), lazy capture-group regexes produce
the same boolean result as greedy non-capturing ones, so there's no
need for two separate caches.

* fix(lite): use TTL for regex cache to evict stale patterns on config reload

Replace NoTTL with 1-hour TTL so patterns from removed routes are
evicted. Active patterns stay alive since Get() refreshes the TTL.

Author: robinbraemer

pkg/edition/java/lite/match.go

@@ -3,6 +3,7 @@ package lite
 import (
 	"regexp"
 	"strings"
+	"time"
 
 	"github.com/jellydator/ttlcache/v3"
 	"go.minekube.com/gate/pkg/edition/java/lite/config"
@@ -36,32 +37,43 @@ func FindRouteWithGroups(pattern string, routes ...config.Route) (host string, r
 	return "", nil, nil
 }
 
+// compiledRegexCache caches compiled glob-to-regex patterns with capture groups.
+// Used by both match (boolean) and matchWithGroups (with captures).
+var compiledRegexCache = ttlcache.New[string, *regexp.Regexp](
+	ttlcache.WithLoader[string, *regexp.Regexp](ttlcache.LoaderFunc[string, *regexp.Regexp](
+		func(c *ttlcache.Cache[string, *regexp.Regexp], pattern string) *ttlcache.Item[string, *regexp.Regexp] {
+			// pattern is the cache key, we must not modify it for the Set call.
+			// Escape all regex metacharacters, then restore glob wildcards as capture groups.
+			regexStr := regexp.QuoteMeta(pattern)
+			regexStr = "^" + strings.ReplaceAll(regexStr, "\\?", "(.)") + "$"
+			regexStr = strings.ReplaceAll(regexStr, "\\*", "(.*?)")
+			reg, _ := regexp.Compile(regexStr)
+
+			return c.Set(pattern, reg, time.Hour)
+		}),
+	),
+)
+
+func getRegexp(pattern string) *regexp.Regexp {
+	pattern = strings.ToLower(pattern)
+	item := compiledRegexCache.Get(pattern)
+	if item == nil {
+		return nil
+	}
+	return item.Value()
+}
+
 // match takes in two strings, s and pattern, and returns a boolean indicating whether s matches pattern.
 //
 // The following special characters are used in pattern:
 //
 //	'*': matches any sequence of characters (including an empty sequence)
 //	'?': matches any single character
 func match(s, pattern string) bool {
-	s = strings.ToLower(s)
-	reg := compiledRegexCache.Get(pattern)
-	return reg != nil && reg.Value() != nil && reg.Value().MatchString(s)
+	reg := getRegexp(pattern)
+	return reg != nil && reg.MatchString(strings.ToLower(s))
 }
 
-var compiledRegexCache = ttlcache.New[string, *regexp.Regexp](
-	ttlcache.WithLoader[string, *regexp.Regexp](ttlcache.LoaderFunc[string, *regexp.Regexp](
-		func(c *ttlcache.Cache[string, *regexp.Regexp], pattern string) *ttlcache.Item[string, *regexp.Regexp] {
-
-			pattern = strings.ToLower(pattern)
-			pattern = "^" + strings.ReplaceAll(pattern, "?", ".") + "$"
-			pattern = strings.ReplaceAll(pattern, "*", ".*")
-			reg, _ := regexp.Compile(pattern)
-
-			return c.Set(pattern, reg, ttlcache.NoTTL)
-		}),
-	),
-)
-
 // matchWithGroups takes in two strings, s and pattern, and returns a boolean indicating whether s matches pattern,
 // along with captured groups from wildcards.
 //
@@ -72,50 +84,12 @@ var compiledRegexCache = ttlcache.New[string, *regexp.Regexp](
 //
 // Returns (matched bool, groups []string) where groups contains the captured values in order.
 func matchWithGroups(s, pattern string) (bool, []string) {
-	s = strings.ToLower(s)
-	pattern = strings.ToLower(pattern)
-
-	// Build regex pattern with capture groups
-	regexPattern := "^"
-
-	// Track if we're inside a character class (not used in current patterns, but for safety)
-	escapeNext := false
-	for _, r := range pattern {
-		if escapeNext {
-			regexPattern += string(r)
-			escapeNext = false
-			continue
-		}
-
-		switch r {
-		case '*':
-			// Each * becomes a capture group (.*?)
-			regexPattern += "(.*?)"
-		case '?':
-			// Each ? becomes a capture group (.)
-			regexPattern += "(.)"
-		case '\\':
-			// Escape next character
-			escapeNext = true
-			regexPattern += "\\"
-		default:
-			// Escape regex special characters
-			if strings.ContainsRune(".^$+()[]{}|", r) {
-				regexPattern += "\\"
-			}
-			regexPattern += string(r)
-		}
-	}
-
-	regexPattern += "$"
-
-	reg, err := regexp.Compile(regexPattern)
-	if err != nil {
-		// If regex compilation fails, fall back to simple match
-		return match(s, pattern), nil
+	reg := getRegexp(pattern)
+	if reg == nil {
+		return false, nil
 	}
 
-	matches := reg.FindStringSubmatch(s)
+	matches := reg.FindStringSubmatch(strings.ToLower(s))
 	if matches == nil {
 		return false, nil
 	}

pkg/edition/java/lite/match_test.go

@@ -37,6 +37,13 @@ func Test_match(t *testing.T) {
 		{"a", "A*", true},
 		{"A", "a*", true},
 		{"abc.example.COm", "*.Example.Com", true},
+		// Dots are treated as literal characters, not regex wildcards
+		{"exampleXcom", "example.com", false},
+		{"example.com", "example.com", true},
+		// Repeated calls with same pattern hit the cache and still work
+		{"foo.example.com", "*.example.com", true},
+		{"bar.example.com", "*.example.com", true},
+		{"notmatching.other.com", "*.example.com", false},
 	}
 
 	for _, test := range tests {
@@ -54,6 +61,60 @@ func BenchmarkMatch(b *testing.B) {
 	}
 }
 
+func BenchmarkMatchWithGroups(b *testing.B) {
+	s := "abc.example.com"
+	pattern := "*.example.*"
+	for b.Loop() {
+		matchWithGroups(s, pattern)
+	}
+}
+
+func Test_matchCacheConsistency(t *testing.T) {
+	// Verify that the cache returns correct results on repeated lookups
+	// with the same pattern. This caught a bug where the loader mutated
+	// the pattern key before storing, causing perpetual cache misses.
+	pattern := "*.example.com"
+	cases := []struct {
+		s    string
+		want bool
+	}{
+		{"first.example.com", true},
+		{"second.example.com", true},
+		{"third.example.com", true},
+		{"notmatching.other.com", false},
+		{"fourth.example.com", true},
+	}
+	for _, tc := range cases {
+		if got := match(tc.s, pattern); got != tc.want {
+			t.Errorf("match(%q, %q) = %v, want %v", tc.s, pattern, got, tc.want)
+		}
+	}
+}
+
+func Test_matchWithGroupsCacheConsistency(t *testing.T) {
+	pattern := "*.example.*"
+	cases := []struct {
+		s          string
+		want       bool
+		wantGroups []string
+	}{
+		{"first.example.com", true, []string{"first", "com"}},
+		{"second.example.org", true, []string{"second", "org"}},
+		{"third.example.net", true, []string{"third", "net"}},
+		{"notmatching.other.com", false, nil},
+		{"fourth.example.io", true, []string{"fourth", "io"}},
+	}
+	for _, tc := range cases {
+		got, groups := matchWithGroups(tc.s, pattern)
+		if got != tc.want {
+			t.Errorf("matchWithGroups(%q, %q) = %v, want %v", tc.s, pattern, got, tc.want)
+		}
+		if !slices.Equal(groups, tc.wantGroups) {
+			t.Errorf("matchWithGroups(%q, %q) groups = %v, want %v", tc.s, pattern, groups, tc.wantGroups)
+		}
+	}
+}
+
 func Test_matchWithGroups(t *testing.T) {
 	tests := []struct {
 		name       string
@@ -212,6 +273,22 @@ func Test_matchWithGroups(t *testing.T) {
 			wantGroups: []string{"abc", "com"},
 		},
 
+		// Dot treated as literal
+		{
+			name:       "dot is literal not regex wildcard",
+			s:          "exampleXcom",
+			pattern:    "example.com",
+			want:       false,
+			wantGroups: nil,
+		},
+		{
+			name:       "dot matches literal dot",
+			s:          "example.com",
+			pattern:    "example.com",
+			want:       true,
+			wantGroups: []string{},
+		},
+
 		// Complex patterns
 		{
 			name:       "multiple stars in sequence",