Merge pull request #9 from AnikHasibul/master

📦 NEW: Router Grouping

Author: Sergio Andrés Virviescas Santana

router.go

@@ -27,6 +27,8 @@
 // func main() {
 //     r := router.New()
 //     r.GET("/", Index)
+//     g := r.Group("/foo", Index)
+//     g.GET("/bar", Index)
 //     r.GET("/hello/:name", Hello)
 
 //     log.Fatal(fasthttp.ListenAndServe(":8080", r.Handler))
@@ -89,7 +91,8 @@ var (
 // Router is a http.Handler which can be used to dispatch requests to different
 // handler functions via configurable routes
 type Router struct {
-	trees map[string]*node
+	beginPath string
+	trees     map[string]*node
 
 	// Enables automatic redirection if the current route can't be matched but a
 	// handler for the path with (without) the trailing slash exists.
@@ -144,6 +147,19 @@ type Router struct {
 // Path auto-correction, including trailing slashes, is enabled by default.
 func New() *Router {
 	return &Router{
+		beginPath:              "/",
+		RedirectTrailingSlash:  true,
+		RedirectFixedPath:      true,
+		HandleMethodNotAllowed: true,
+		HandleOPTIONS:          true,
+	}
+}
+
+// Group returns a new grouped Router.
+// Path auto-correction, including trailing slashes, is enabled by default.
+func (r *Router) Group(path string) *Router {
+	return &Router{
+		beginPath:              path,
 		RedirectTrailingSlash:  true,
 		RedirectFixedPath:      true,
 		HandleMethodNotAllowed: true,
@@ -198,7 +214,9 @@ func (r *Router) Handle(method, path string, handle fasthttp.RequestHandler) {
 	if path[0] != '/' {
 		panic("path must begin with '/' in path '" + path + "'")
 	}
-
+	if r.beginPath != "/" {
+		path = r.beginPath + path
+	}
 	if r.trees == nil {
 		r.trees = make(map[string]*node)
 	}

router_test.go

@@ -309,6 +309,92 @@ func TestRouterChaining(t *testing.T) {
 	}
 }
 
+func TestRouterGroup(t *testing.T) {
+	r1 := New()
+	r2 := r1.Group("/boo")
+	r1.NotFound = r2.Handler
+	fooHit := false
+	r1.POST("/foo", func(ctx *fasthttp.RequestCtx) {
+		fooHit = true
+		ctx.SetStatusCode(fasthttp.StatusOK)
+	})
+
+	barHit := false
+	r2.POST("/bar", func(ctx *fasthttp.RequestCtx) {
+		barHit = true
+		ctx.SetStatusCode(fasthttp.StatusOK)
+	})
+
+	s := &fasthttp.Server{
+		Handler: r1.Handler,
+	}
+
+	rw := &readWriter{}
+	ch := make(chan error)
+
+	rw.r.WriteString("POST /foo HTTP/1.1\r\n\r\n")
+	go func() {
+		ch <- s.ServeConn(rw)
+	}()
+	select {
+	case err := <-ch:
+		if err != nil {
+			t.Fatalf("return error %s", err)
+		}
+	case <-time.After(100 * time.Millisecond):
+		t.Fatalf("timeout")
+	}
+	br := bufio.NewReader(&rw.w)
+	var resp fasthttp.Response
+	if err := resp.Read(br); err != nil {
+		t.Fatalf("Unexpected error when reading response: %s", err)
+	}
+	if !(resp.Header.StatusCode() == fasthttp.StatusOK && fooHit) {
+		t.Errorf("Regular routing failed with router chaining.")
+		t.FailNow()
+	}
+
+	rw.r.WriteString("POST /boo/bar HTTP/1.1\r\n\r\n")
+	go func() {
+		ch <- s.ServeConn(rw)
+	}()
+	select {
+	case err := <-ch:
+		if err != nil {
+			t.Fatalf("return error %s", err)
+		}
+	case <-time.After(100 * time.Millisecond):
+		t.Fatalf("timeout")
+	}
+	if err := resp.Read(br); err != nil {
+		t.Fatalf("Unexpected error when reading response: %s", err)
+	}
+	if !(resp.Header.StatusCode() == fasthttp.StatusOK && barHit) {
+		t.Errorf("Chained routing failed with router chaining.")
+		t.FailNow()
+	}
+
+	rw.r.WriteString("POST /qax HTTP/1.1\r\n\r\n")
+	go func() {
+		ch <- s.ServeConn(rw)
+	}()
+	select {
+	case err := <-ch:
+		if err != nil {
+			t.Fatalf("return error %s", err)
+		}
+	case <-time.After(100 * time.Millisecond):
+		t.Fatalf("timeout")
+	}
+	if err := resp.Read(br); err != nil {
+		t.Fatalf("Unexpected error when reading response: %s", err)
+	}
+	if !(resp.Header.StatusCode() == fasthttp.StatusNotFound) {
+		t.Errorf("NotFound behavior failed with router chaining.")
+		t.FailNow()
+	}
+}
+
 func TestRouterOPTIONS(t *testing.T) {
 	// TODO: because fasthttp is not support OPTIONS method now,
 	// these test cases will be used in the future.