Implement regex caching for CurlyRouter and custom verbs

Author: Wen Huang

curly.go

@@ -9,11 +9,16 @@ import (
 	"regexp"
 	"sort"
 	"strings"
+	"sync"
 )
 
 // CurlyRouter expects Routes with paths that contain zero or more parameters in curly brackets.
 type CurlyRouter struct{}
 
+var (
+	regexCache sync.Map // Cache for compiled regex patterns
+)
+
 // SelectRoute is part of the Router interface and returns the best match
 // for the WebService and its Route for the given Request.
 func (c CurlyRouter) SelectRoute(
@@ -113,8 +118,22 @@ func (c CurlyRouter) regularMatchesPathToken(routeToken string, colon int, reque
 		}
 		return true, true
 	}
-	matched, err := regexp.MatchString(regPart, requestToken)
-	return (matched && err == nil), false
+	
+	// Check cache first
+	if cached, found := regexCache.Load(regPart); found {
+		regex := cached.(*regexp.Regexp)
+		matched := regex.MatchString(requestToken)
+		return matched, false
+	}
+	
+	// Compile and cache the regex
+	regex, err := regexp.Compile(regPart)
+	if err != nil {
+		return false, false
+	}
+	regexCache.Store(regPart, regex)
+	matched := regex.MatchString(requestToken)
+	return matched, false
 }
 
 var jsr311Router = RouterJSR311{}

curly_test.go

@@ -3,6 +3,7 @@ package restful
 import (
 	"io"
 	"net/http"
+	"sync"
 	"testing"
 )
 
@@ -262,3 +263,49 @@ func TestCurly_ISSUE_137_2(t *testing.T) {
 }
 
 func curlyDummy(req *Request, resp *Response) { io.WriteString(resp.ResponseWriter, "curlyDummy") }
+
+func TestRegexCaching(t *testing.T) {
+	// Clear cache before test
+	regexCache = sync.Map{}
+	
+	router := CurlyRouter{}
+	
+	// Test with regex pattern
+	routeToken := "{id:[0-9]+}"
+	requestToken := "123"
+	
+	// First call should cache the regex
+	matches1, _ := router.regularMatchesPathToken(routeToken, 3, requestToken)
+	if !matches1 {
+		t.Error("Expected first call to match")
+	}
+	
+	// Verify cache contains the pattern
+	pattern := "[0-9]+"
+	_, found := regexCache.Load(pattern)
+	if !found {
+		t.Error("Expected pattern to be cached")
+	}
+	
+	// Second call should use cached regex
+	matches2, _ := router.regularMatchesPathToken(routeToken, 3, requestToken)
+	if !matches2 {
+		t.Error("Expected second call to match using cache")
+	}
+	
+	// Test with different pattern to ensure separate caching
+	routeToken2 := "{name:[a-z]+}"
+	requestToken2 := "john"
+	
+	matches3, _ := router.regularMatchesPathToken(routeToken2, 5, requestToken2)
+	if !matches3 {
+		t.Error("Expected name pattern to match")
+	}
+	
+	// Verify both patterns are cached
+	pattern2 := "[a-z]+"
+	_, found2 := regexCache.Load(pattern2)
+	if !found2 {
+		t.Error("Expected name pattern to be cached")
+	}
+}

custom_verb.go

@@ -3,10 +3,12 @@ package restful
 import (
 	"fmt"
 	"regexp"
+	"sync"
 )
 
 var (
-	customVerbReg = regexp.MustCompile(":([A-Za-z]+)$")
+	customVerbReg   = regexp.MustCompile(":([A-Za-z]+)$")
+	customVerbCache sync.Map // Cache for compiled custom verb regexes
 )
 
 func hasCustomVerb(routeToken string) bool {
@@ -20,7 +22,17 @@ func isMatchCustomVerb(routeToken string, pathToken string) bool {
 	}
 
 	customVerb := rs[1]
-	specificVerbReg := regexp.MustCompile(fmt.Sprintf(":%s$", customVerb))
+	regexPattern := fmt.Sprintf(":%s$", customVerb)
+
+	// Check cache first
+	if cached, found := customVerbCache.Load(regexPattern); found {
+		specificVerbReg := cached.(*regexp.Regexp)
+		return specificVerbReg.MatchString(pathToken)
+	}
+
+	// Compile and cache the regex
+	specificVerbReg := regexp.MustCompile(regexPattern)
+	customVerbCache.Store(regexPattern, specificVerbReg)
 	return specificVerbReg.MatchString(pathToken)
 }
 

custom_verb_test.go

@@ -1,6 +1,9 @@
 package restful
 
-import "testing"
+import (
+	"sync"
+	"testing"
+)
 
 func TestHasCustomVerb(t *testing.T) {
 	testCase := []struct {
@@ -40,6 +43,7 @@ func TestRemoveCustomVerb(t *testing.T) {
 		}
 	}
 }
+
 func TestMatchCustomVerb(t *testing.T) {
 	testCase := []struct {
 		routeToken string
@@ -60,3 +64,46 @@ func TestMatchCustomVerb(t *testing.T) {
 		}
 	}
 }
+
+func TestCustomVerbCaching(t *testing.T) {
+	// Clear cache before test
+	customVerbCache = sync.Map{}
+	
+	routeToken := "{userId:regex}:POST"
+	pathToken := "user123:POST"
+	
+	// First call should cache the regex
+	result1 := isMatchCustomVerb(routeToken, pathToken)
+	if !result1 {
+		t.Error("Expected first call to match")
+	}
+	
+	// Verify cache contains the pattern
+	pattern := ":POST$"
+	_, found := customVerbCache.Load(pattern)
+	if !found {
+		t.Error("Expected pattern to be cached")
+	}
+	
+	// Second call should use cached regex
+	result2 := isMatchCustomVerb(routeToken, pathToken)
+	if !result2 {
+		t.Error("Expected second call to match using cache")
+	}
+	
+	// Test with different verb to ensure separate caching
+	routeToken2 := "{userId:regex}:GET"
+	pathToken2 := "user123:GET"
+	
+	result3 := isMatchCustomVerb(routeToken2, pathToken2)
+	if !result3 {
+		t.Error("Expected GET verb to match")
+	}
+	
+	// Verify both patterns are cached
+	pattern2 := ":GET$"
+	_, found2 := customVerbCache.Load(pattern2)
+	if !found2 {
+		t.Error("Expected GET pattern to be cached")
+	}
+}