Add support for relaxed route placeholder

Notation is #param (used by other frameworks, and inspired by Mojilicious)
It catches all chars until the first '/' or the end of the string.

Author: ant0ine

rest/trie/impl.go

@@ -22,14 +22,28 @@ func splitParam(remaining string) (string, string) {
 	return remaining[:i], remaining[i:]
 }
 
+func splitRelaxed(remaining string) (string, string) {
+	i := 0
+	for len(remaining) > i && remaining[i] != '/' {
+		i++
+	}
+	return remaining[:i], remaining[i:]
+}
+
 type node struct {
 	HttpMethodToRoute map[string]interface{}
-	Children          map[string]*node
-	ChildrenKeyLen    int
-	ParamChild        *node
-	ParamName         string
-	SplatChild        *node
-	SplatName         string
+
+	Children       map[string]*node
+	ChildrenKeyLen int
+
+	ParamChild *node
+	ParamName  string
+
+	RelaxedChild *node
+	RelaxedName  string
+
+	SplatChild *node
+	SplatName  string
 }
 
 func (n *node) addRoute(httpMethod, pathExp string, route interface{}, usedParams []string) error {
@@ -84,6 +98,36 @@ func (n *node) addRoute(httpMethod, pathExp string, route interface{}, usedParam
 			}
 		}
 		nextNode = n.ParamChild
+	} else if token[0] == '#' {
+		// #param case
+		var name string
+		name, remaining = splitRelaxed(remaining)
+
+		// Check param name is unique
+		for _, e := range usedParams {
+			if e == name {
+				return errors.New(
+					fmt.Sprintf("A route can't have two placeholders with the same name: %s", name),
+				)
+			}
+		}
+		usedParams = append(usedParams, name)
+
+		if n.RelaxedChild == nil {
+			n.RelaxedChild = &node{}
+			n.RelaxedName = name
+		} else {
+			if n.RelaxedName != name {
+				return errors.New(
+					fmt.Sprintf(
+						"Routes sharing a common placeholder MUST name it consistently: %s != %s",
+						n.RelaxedName,
+						name,
+					),
+				)
+			}
+		}
+		nextNode = n.RelaxedChild
 	} else if token[0] == '*' {
 		// *splat case
 		name := remaining
@@ -194,6 +238,14 @@ func (n *node) find(httpMethod, path string, context *findContext) {
 		context.popParams()
 	}
 
+	// #param branch
+	if n.RelaxedChild != nil {
+		value, remaining := splitRelaxed(path)
+		context.pushParams(n.RelaxedName, value)
+		n.RelaxedChild.find(httpMethod, remaining, context)
+		context.popParams()
+	}
+
 	// main branch
 	length := n.ChildrenKeyLen
 	if len(path) < length {
@@ -215,14 +267,18 @@ func (n *node) compress() {
 	if n.ParamChild != nil {
 		n.ParamChild.compress()
 	}
+	// #param branch
+	if n.RelaxedChild != nil {
+		n.RelaxedChild.compress()
+	}
 	// main branch
 	if len(n.Children) == 0 {
 		return
 	}
 	// compressable ?
 	canCompress := true
 	for _, node := range n.Children {
-		if node.HttpMethodToRoute != nil || node.SplatChild != nil || node.ParamChild != nil {
+		if node.HttpMethodToRoute != nil || node.SplatChild != nil || node.ParamChild != nil || node.RelaxedChild != nil {
 			canCompress = false
 		}
 	}

rest/trie/impl_test.go

@@ -50,8 +50,8 @@ func TestTrieCompression(t *testing.T) {
 	if trie.root.Children["/adc"] == nil {
 		t.Errorf("%+v", trie.root)
 	}
-
 }
+
 func TestParamInsert(t *testing.T) {
 	trie := New()
 
@@ -78,6 +78,18 @@ func TestParamInsert(t *testing.T) {
 	}
 }
 
+func TestRelaxedInsert(t *testing.T) {
+	trie := New()
+
+	trie.AddRoute("GET", "/#id/", "")
+	if trie.root.Children["/"].RelaxedChild.Children["/"] == nil {
+		t.Error()
+	}
+	if trie.root.Children["/"].RelaxedName != "id" {
+		t.Error()
+	}
+}
+
 func TestSplatInsert(t *testing.T) {
 	trie := New()
 	trie.AddRoute("GET", "/*splat", "")
@@ -115,6 +127,7 @@ func TestFindRoute(t *testing.T) {
 	trie.AddRoute("GET", "/r/:id", "resource")
 	trie.AddRoute("GET", "/r/:id/property", "property")
 	trie.AddRoute("GET", "/r/:id/property.*format", "property_format")
+	trie.AddRoute("GET", "/user/#username/property", "user_property")
 
 	trie.Compress()
 
@@ -166,6 +179,17 @@ func TestFindRoute(t *testing.T) {
 	if matches[0].Params["format"] != "json" {
 		t.Error()
 	}
+
+	matches = trie.FindRoutes("GET", "/user/antoine.imbert/property")
+	if len(matches) != 1 {
+		t.Errorf("expected one route, got %d", len(matches))
+	}
+	if !isInMatches("user_property", matches) {
+		t.Error("expected 'user_property'")
+	}
+	if matches[0].Params["username"] != "antoine.imbert" {
+		t.Error()
+	}
 }
 
 func TestFindRouteMultipleMatches(t *testing.T) {
@@ -177,6 +201,7 @@ func TestFindRouteMultipleMatches(t *testing.T) {
 	trie.AddRoute("GET", "/r/:id", "resource_generic")
 	trie.AddRoute("GET", "/s/*rest", "special_all")
 	trie.AddRoute("GET", "/s/:param", "special_generic")
+	trie.AddRoute("GET", "/s/#param", "special_relaxed")
 	trie.AddRoute("GET", "/", "root")
 
 	trie.Compress()
@@ -193,7 +218,7 @@ func TestFindRouteMultipleMatches(t *testing.T) {
 	}
 
 	matches = trie.FindRoutes("GET", "/s/1")
-	if len(matches) != 2 {
+	if len(matches) != 3 {
 		t.Errorf("expected two matches, got %d", len(matches))
 	}
 	if !isInMatches("special_all", matches) {
@@ -202,16 +227,28 @@ func TestFindRouteMultipleMatches(t *testing.T) {
 	if !isInMatches("special_generic", matches) {
 		t.Error()
 	}
+	if !isInMatches("special_relaxed", matches) {
+		t.Error()
+	}
 }
 
 func TestConsistentPlaceholderName(t *testing.T) {
 
 	trie := New()
+
 	trie.AddRoute("GET", "/r/:id", "oneph")
 	err := trie.AddRoute("GET", "/r/:rid/other", "twoph")
 	if err == nil {
 		t.Error("Should have died on adding second route")
 	}
+
+	trie.AddRoute("GET", "/r/#id", "oneph")
+	err = trie.AddRoute("GET", "/r/#rid/other", "twoph")
+	if err == nil {
+		t.Error("Should have died on adding second route")
+	}
+
+	// TODO *param
 }
 
 func TestDuplicateName(t *testing.T) {
@@ -227,4 +264,9 @@ func TestDuplicateName(t *testing.T) {
 	if err == nil {
 		t.Error("Should have died, this route has two placeholder named `id`")
 	}
+
+	err = trie.AddRoute("GET", "/r/:id/o/#id", "two")
+	if err == nil {
+		t.Error("Should have died, this route has two placeholder named `id`")
+	}
 }