added escaping colon to avoid confusions between wildcards and and non-wildcards

Author: flrdv

router/inbuilt/internal/radix/tree.go

@@ -209,8 +209,9 @@ func (n *Node[T]) appendPredecessor(node *Node[T]) {
 	n.predecessors = append(n.predecessors, node)
 }
 
-func IsDynamicTemplate(str string) bool {
-	return strings.IndexByte(str, ':') != -1
+func IsDynamicTemplate(path string) bool {
+	segs := splitPath(path)
+	return len(segs) > 1 || segs[0].IsWildcard
 }
 
 func truncCommon(segs []pathSegment, length int) []pathSegment {
@@ -237,15 +238,26 @@ type pathSegment struct {
 	Value      string
 }
 
-func splitPath(str string) (result []pathSegment) {
+func splitPath(str string) (path []pathSegment) {
+	offset := 0
+
 	for len(str) > 0 {
-		colon := strings.IndexByte(str, ':')
+		colon := strings.IndexByte(str[offset:], ':')
 		if colon == -1 {
-			result = append(result, pathSegment{false, false, str})
+			path = append(path, pathSegment{false, false, str})
 			break
 		}
 
-		result = append(result, pathSegment{false, false, str[:colon]})
+		colon += offset
+
+		if colon > 0 && str[colon-1] == '\\' {
+			// escaped colon: isn't a wildcard, skip
+			str = str[:colon-1] + str[colon:]
+			offset = colon
+			continue
+		}
+
+		path = append(path, pathSegment{false, false, str[:colon]})
 		str = str[colon+1:]
 
 		boundary := strings.IndexByte(str, '/')
@@ -256,17 +268,17 @@ func splitPath(str string) (result []pathSegment) {
 		wildcard := str[:boundary]
 		greedy := false
 		if strings.HasSuffix(wildcard, "...") {
-			wildcard = wildcard[:len(wildcard)-3]
+			wildcard = wildcard[:len(wildcard)-len("...")]
 			greedy = true
 		}
 
-		result = append(result, pathSegment{true, greedy, wildcard})
+		path = append(path, pathSegment{true, greedy, wildcard})
 		if boundary < len(str) {
 			boundary++
 		}
 
 		str = str[boundary:]
 	}
 
-	return result
+	return path
 }

router/inbuilt/internal/radix/tree_test.go

@@ -141,6 +141,14 @@ func TestTree(t *testing.T) {
 		require.Equal(t, "wow", wildcards.Value("id"))
 	})
 
+	test := func(t *testing.T, tree *Node[int], path string, value int, wKey, wVal string) {
+		w := kv.New()
+		val, found := tree.Lookup(path, w)
+		require.True(t, found)
+		require.Equal(t, value, val)
+		require.Equal(t, wVal, w.Value(wKey))
+	}
+
 	t.Run("dynamic in the middle", func(t *testing.T) {
 		tree := New[int]()
 		require.NoError(t, tree.Insert("/user/:id", 1))
@@ -220,14 +228,40 @@ func TestTree(t *testing.T) {
 		test(t, tree, "/prefix42", 1, "path", "42")
 		test(t, tree, "/prefixnowhere/like/this", 1, "path", "nowhere/like/this")
 	})
-}
 
-func test(t *testing.T, tree *Node[int], path string, value int, wKey, wVal string) {
-	w := kv.New()
-	val, found := tree.Lookup(path, w)
-	require.True(t, found)
-	require.Equal(t, value, val)
-	require.Equal(t, wVal, w.Value(wKey))
+	t.Run("escape wildcard", func(t *testing.T) {
+		t.Run("static leftmost", func(t *testing.T) {
+			tree := New[int]()
+			require.NoError(t, tree.Insert("\\:hello/\\:world", 1))
+			value, found := tree.Lookup(":hello/:world", nil)
+			require.True(t, found)
+			require.Equal(t, 1, value)
+		})
+
+		t.Run("static rightmost", func(t *testing.T) {
+			tree := New[int]()
+			require.NoError(t, tree.Insert("/\\:hello", 1))
+			value, found := tree.Lookup("/:hello", nil)
+			require.True(t, found)
+			require.Equal(t, 1, value)
+		})
+
+		t.Run("dynamic", func(t *testing.T) {
+			tree := New[int]()
+			require.NoError(t, tree.Insert("/\\:hello/:name", 1))
+			wildcards := kv.New()
+			value, found := tree.Lookup("/:hello/Pavlo", wildcards)
+			require.True(t, found)
+			require.Equal(t, 1, value)
+			require.Equal(t, "Pavlo", wildcards.Value("name"))
+		})
+	})
+
+	t.Run("path classifier", func(t *testing.T) {
+		require.False(t, IsDynamicTemplate("\\:hello/\\:world"))
+		require.False(t, IsDynamicTemplate("/\\:hello"))
+		require.True(t, IsDynamicTemplate("/\\:hello/:name"))
+	})
 }
 
 // isn't used anymore. Left just in case the tree needs to be debugged.