Add support for wildcards on the routes.

Author: leonelquinteros

README.md

@@ -153,6 +153,72 @@ func (h *Hello) Get(c *yarf.Context) error {
 ```
 
 
+### Route wildcards
+
+When some extra freedom is needed on your routes, you can use a `*` as part of your routes to match anything where the wildcard is present. 
+
+The route: 
+
+```
+/something/*/here
+```
+
+Will match the routes
+
+```
+/something/is/here
+/something/happen/here
+/something/isnt/here
+/something/was/here
+```
+
+And so on... 
+
+You can also combine this with parameters inside the routes for extra complexity.
+
+
+### Catch-All wildcard
+
+When using the `*` at the end of any route, the router will match everything from the wildcard and forward. 
+
+The route: 
+
+```
+/match/from/here/*
+```
+
+Will match: 
+
+```
+/match/from/here
+/match/from/here/please
+/match/from/here/and/forward
+/match/from/here/and/forward/for/ever/and/ever
+```
+
+And so on...
+
+
+#### Note about the wildcard
+
+The `*` can only be used by itself and it doesn't works for single character matching like in regex. 
+
+So the route:
+ 
+```
+/match/some*
+```
+
+Will **NOT** match:
+
+```
+/match/some
+/match/something
+/match/someone
+/match/some/please
+```
+
+
 ### Context
 
 The Context object is passed as a parameter to all Resource methods and contains all the information related to the ongoing request. 

router.go

@@ -51,8 +51,11 @@ func (r *route) Match(url string, c *Context) bool {
 	requestParts := prepareURL(url)
 
 	// YARF router only accepts exact route matches, so check for part count.
-	if len(r.routeParts) != len(requestParts) {
-		return false
+	// Unless it's a catch-all route
+	if len(r.routeParts) == 0 || (len(r.routeParts) > 0 && r.routeParts[len(r.routeParts)-1] != "*") {
+		if len(r.routeParts) != len(requestParts) {
+			return false
+		}
 	}
 
 	// check that requestParts matches routeParts
@@ -257,12 +260,23 @@ func removeEmpty(parts []string) []string {
 // matches returns true if requestParts matches routeParts up through len(routeParts)
 // ignoring params in routeParts
 func matches(routeParts, requestParts []string) bool {
-	if len(requestParts) < len(routeParts) {
+	routeCount := len(routeParts)
+
+	// Check for catch-all wildcard
+	if len(routeParts) > 0 && routeParts[len(routeParts)-1] == "*" {
+		routeCount--
+	}
+
+	if len(requestParts) < routeCount {
 		return false
 	}
 
-	// Check for part matching, ignoring params
+	// Check for part matching, ignoring params and * wildcards
 	for i, p := range routeParts {
+		// Skip wildcard
+		if p == "*" {
+			continue
+		}
 		if p != requestParts[i] && p[0] != ':' {
 			return false
 		}

router_test.go

@@ -33,6 +33,28 @@ func TestRouterRootMatch(t *testing.T) {
 	}
 }
 
+func TestRouterRootCatchAll(t *testing.T) {
+	// Create empty handler
+	h := new(Handler)
+
+	// Create empty context
+	c := new(Context)
+	c.Params = url.Values{}
+
+	// Create route
+	r := Route("/*", h)
+
+	// Matching routes
+	rs := []string{"/", "", "/something", "/*", "/something/else/more"}
+
+	// Check
+	for _, s := range rs {
+		if !r.Match(s, c) {
+			t.Errorf("'%s' should match against '*'", s)
+		}
+	}
+}
+
 func TestRouterRootUnmatch(t *testing.T) {
 	// Create empty handler
 	h := new(Handler)
@@ -77,6 +99,28 @@ func TestRouter1LevelMatch(t *testing.T) {
 	}
 }
 
+func TestRouter1LevelCatchAll(t *testing.T) {
+	// Create empty handler
+	h := new(Handler)
+
+	// Create empty context
+	c := new(Context)
+	c.Params = url.Values{}
+
+	// Create route
+	r := Route("/level/*", h)
+
+	// Matching routes
+	rs := []string{"/level/something", "level/something", "/level/*", "/level/something/else/and/more/because/this/matches/all"}
+
+	// Check
+	for _, s := range rs {
+		if !r.Match(s, c) {
+			t.Errorf("'%s' should match against '/level/*'", s)
+		}
+	}
+}
+
 func TestRouter1LevelUnmatch(t *testing.T) {
 	// Create empty handler
 	h := new(Handler)
@@ -121,6 +165,50 @@ func TestRouterMultiLevelMatch(t *testing.T) {
 	}
 }
 
+func TestRouterMultiLevelWildcard(t *testing.T) {
+	// Create empty handler
+	h := new(Handler)
+
+	// Create empty context
+	c := new(Context)
+	c.Params = url.Values{}
+
+	// Create route
+	r := Route("/a/b/*/d", h)
+
+	// Matching routes
+	rs := []string{"/a/b/c/d", "a/b/c/d", "/a/b/*/d", "a/b/something/d"}
+
+	// Check
+	for _, s := range rs {
+		if !r.Match(s, c) {
+			t.Errorf("'%s' should match against '/a/b/*/d", s)
+		}
+	}
+}
+
+func TestRouterMultiLevelCatchAll(t *testing.T) {
+	// Create empty handler
+	h := new(Handler)
+
+	// Create empty context
+	c := new(Context)
+	c.Params = url.Values{}
+
+	// Create route
+	r := Route("/a/b/*", h)
+
+	// Matching routes
+	rs := []string{"/a/b/c", "a/b/c", "/a/b/c/d/e", "a/b/c/d"}
+
+	// Check
+	for _, s := range rs {
+		if !r.Match(s, c) {
+			t.Errorf("'%s' should match against '/a/b/*", s)
+		}
+	}
+}
+
 func TestRouterMultiLevelUnmatch(t *testing.T) {
 	// Create empty handler
 	h := new(Handler)
@@ -165,6 +253,28 @@ func TestRouter1LevelParamMatch(t *testing.T) {
 	}
 }
 
+func TestRouter1LevelParamCatchAll(t *testing.T) {
+	// Create empty handler
+	h := new(Handler)
+
+	// Create empty context
+	c := new(Context)
+	c.Params = url.Values{}
+
+	// Create route
+	r := Route("/:param/*", h)
+
+	// Matching routes
+	rs := []string{"/a", "a", "/cafewafewa", "/:paramStyle", "/trailer/", "/something/more/to/catch"}
+
+	// Check
+	for _, s := range rs {
+		if !r.Match(s, c) {
+			t.Errorf("'%s' should match against '/:param/*'", s)
+		}
+	}
+}
+
 func TestRouter1LevelParamUnmatch(t *testing.T) {
 	// Create empty handler
 	h := new(Handler)
@@ -209,6 +319,50 @@ func TestRouterMultiLevelParamMatch(t *testing.T) {
 	}
 }
 
+func TestRouterMultiLevelParamWildcard(t *testing.T) {
+	// Create empty handler
+	h := new(Handler)
+
+	// Create empty context
+	c := new(Context)
+	c.Params = url.Values{}
+
+	// Create route
+	r := Route("/a/*/:param", h)
+
+	// Matching routes
+	rs := []string{"/a/b/c", "a/b/c", "/a/b/c/", "a/b/c/", "/a/b/:c", "/a/b/:param"}
+
+	// Check
+	for _, s := range rs {
+		if !r.Match(s, c) {
+			t.Errorf("'%s' should match against '/a/*/:param'", s)
+		}
+	}
+}
+
+func TestRouterMultiLevelParamCatchAll(t *testing.T) {
+	// Create empty handler
+	h := new(Handler)
+
+	// Create empty context
+	c := new(Context)
+	c.Params = url.Values{}
+
+	// Create route
+	r := Route("/a/b/:param/*", h)
+
+	// Matching routes
+	rs := []string{"/a/b/c", "a/b/c", "/a/b/c/", "a/b/c/", "/a/b/:c", "/a/b/:param", "/a/b/c/d/e/f/g", "/a/b/c/d/:param/*"}
+
+	// Check
+	for _, s := range rs {
+		if !r.Match(s, c) {
+			t.Errorf("'%s' should match against '/a/b/:param/*'", s)
+		}
+	}
+}
+
 func TestRouterMultiLevelParamUnmatch(t *testing.T) {
 	// Create empty handler
 	h := new(Handler)
@@ -328,6 +482,29 @@ func TestRouterGroupMatch(t *testing.T) {
 	}
 }
 
+func TestRouterGroupCatchAll(t *testing.T) {
+	// Create empty handler
+	h := new(Handler)
+
+	// Create empty context
+	c := new(Context)
+	c.Params = url.Values{}
+
+	// Create group
+	g := RouteGroup("/v1")
+	g.Add("/test/*", h)
+
+	// Matching routes
+	rs := []string{"/v1/test/test", "/v1/test/:param/", "/v1/test/this/is/a/wild/card"}
+
+	// Check
+	for _, s := range rs {
+		if !g.Match(s, c) {
+			t.Errorf("'%s' should match", s)
+		}
+	}
+}
+
 func TestRouterGroupNotMatch(t *testing.T) {
 	// Create empty handler
 	h := new(Handler)

yarf.go

@@ -6,7 +6,7 @@ import (
 )
 
 // Framework version string
-const Version = "0.7"
+const Version = "0.7.1"
 
 // Yarf is the main entry point for the framework and it centralizes most of the functionality.
 // All configuration actions are handled by this object.
@@ -147,14 +147,6 @@ func (y *Yarf) finish(c *Context, err error) {
 		return
 	}
 
-	// Write error data to response.
-	c.Response.WriteHeader(yerr.Code())
-
-	// Render errors if debug enabled
-	if y.Debug {
-		c.Render(yerr.Body())
-	}
-
 	// Log errors
 	if y.Logger != nil {
 		y.Logger.Printf(
@@ -165,6 +157,14 @@ func (y *Yarf) finish(c *Context, err error) {
 			yerr.Msg(),
 		)
 	}
+
+	// Render errors if debug enabled
+	if y.Debug {
+		c.Render(yerr.Body())
+	}
+
+	// Write error data to response.
+	c.Response.WriteHeader(yerr.Code())
 }
 
 // Start initiates a new http yarf server and start listening.