Squashed commit of the following:

commit 64f9917f6c5636b301f43a8a8c8a9de0e8c0f8b5
Author: Sergio Andres Virviescas Santana <[email protected]>
Date:   Sun Dec 30 22:29:15 2018 +0100

    General fixes

commit fefd45ee1d266fe0cc7be8a2e501e6943260ddc4
Author: Sergio Andres Virviescas Santana <[email protected]>
Date:   Sun Dec 30 22:16:22 2018 +0100

    Fixes

commit 42801773c2cb92038a61e99e7eeef0964bc4cada
Author: Sergio Andres Virviescas Santana <[email protected]>
Date:   Fri Dec 28 23:27:56 2018 +0100

    Remove unsed function

commit 4c0e664a2073394262d51f50e45376a3e478ffe0
Author: Sergio Andres Virviescas Santana <[email protected]>
Date:   Fri Dec 28 23:23:22 2018 +0100

    Added BenchmarkRouterRedirectTrailingSlash

commit c07cc54d47e19fae4229d3f2205e806ebe258cb0
Author: Sergio Andres Virviescas Santana <[email protected]>
Date:   Fri Dec 28 23:18:50 2018 +0100

    Fixes to non break API

commit f0cd9995c478278aa3d7992d46192ee98fd8add8
Author: Sergio Andres Virviescas Santana <[email protected]>
Date:   Wed Dec 26 18:05:08 2018 +0100

    Reduce extra allocations to 0

commit fe4e3adf60a99314df7e117c6d14d091e88674f8
Author: Sergio Andres Virviescas Santana <[email protected]>
Date:   Wed Dec 26 17:15:20 2018 +0100

    Reduce 1 alloc and a insignificant time

commit 57a058e3c74d4ea514c1154e2423665e2f4e8183
Author: Sergio Andres Virviescas Santana <[email protected]>
Date:   Wed Dec 26 16:15:59 2018 +0100

    Avoided defer releaseCleanPathBuffer

commit 42a3f75dc63fb7be02a58bbe11c21505540f714a
Author: Sergio Andres Virviescas Santana <[email protected]>
Date:   Wed Dec 26 15:48:03 2018 +0100

    Added some improvements

Author: Sergio Andres Virviescas Santana

LICENSE

@@ -1,4 +1,6 @@
 Copyright (c) 2015-2016, 招牌疯子
+Copyright (c) 2018-present Sergio Andres Virviescas Santana, fasthttp
+
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

README.md

@@ -18,13 +18,10 @@ This router is optimized for high performance and a small memory footprint. It s
 - I fork this repo is just because there is no router for `fasthttp` at that time. And `router` is the FIRST router for `fasthttp`. 
 - `router` has been used in my online production and processes 17 million requests per day. It is fast and stable, so I decide to release a stable version.
 
-#### Releases
-
-- [2016.10.24] [v0.1.0](https://github.com/fasthttp/router/releases/tag/v0.1.0) The first release version of `router`.
 
 ## Features
 
-**Best Performance:** FastHttpRouter is **one of the fastest** go web frameworks in the [go-web-framework-benchmark](https://github.com/smallnest/go-web-framework-benchmark). Even faster than httprouter itself.
+**Best Performance:** Router is **one of the fastest** go web frameworks in the [go-web-framework-benchmark](https://github.com/smallnest/go-web-framework-benchmark). Even faster than httprouter itself.
 
 - Basic Test: The first test case is to mock 0 ms, 10 ms, 100 ms, 500 ms processing time in handlers. The concurrency clients are 5000.
 
@@ -52,7 +49,7 @@ If you don't like it, you can [turn off this behavior](http://godoc.org/github.c
 slash at no extra cost, the router can also fix wrong cases and remove
 superfluous path elements (like `../` or `//`).
 Is [CAPTAIN CAPS LOCK](http://www.urbandictionary.com/define.php?term=Captain+Caps+Lock) one of your users?
-FastHttpRouter can help him by making a case-insensitive look-up and redirecting him
+Router can help him by making a case-insensitive look-up and redirecting him
 to the correct URL.
 
 **Parameters in your routing pattern:** Stop parsing the requested URL path,
@@ -92,19 +89,19 @@ import (
 )
 
 func Index(ctx *fasthttp.RequestCtx) {
-	fmt.Fprint(ctx, "Welcome!\n")
+	ctx.WriteString("Welcome!")
 }
 
 func Hello(ctx *fasthttp.RequestCtx) {
-	fmt.Fprintf(ctx, "hello, %s!\n", ctx.UserValue("name"))
+	fmt.Fprintf(ctx, "Hello, %s!\n", ctx.UserValue("name"))
 }
 
 func main() {
-	router := router.New()
-	router.GET("/", Index)
-	router.GET("/hello/:name", Hello)
+	r := router.New()
+	r.GET("/", Index)
+	r.GET("/hello/:name", Hello)
 
-	log.Fatal(fasthttp.ListenAndServe(":8080", router.Handler))
+	log.Fatal(fasthttp.ListenAndServe(":8080", r.Handler))
 }
 ```
 
@@ -180,9 +177,9 @@ For even better scalability, the child nodes on each tree level are ordered by p
 
 Because fasthttp doesn't provide http.Handler. See this [description](https://github.com/valyala/fasthttp#switching-from-nethttp-to-fasthttp).
 
-Fasthttp works with [RequestHandler](https://godoc.org/github.com/valyala/fasthttp#RequestHandler) functions instead of objects implementing Handler interface. So a FastHttpRouter provides a [Handler](https://godoc.org/github.com/fasthttp/router#Router.Handler) interface to implement the fasthttp.ListenAndServe interface.
+Fasthttp works with [RequestHandler](https://godoc.org/github.com/valyala/fasthttp#RequestHandler) functions instead of objects implementing Handler interface. So a Router provides a [Handler](https://godoc.org/github.com/fasthttp/router#Router.Handler) interface to implement the fasthttp.ListenAndServe interface.
 
-Just try it out for yourself, the usage of FastHttpRouter is very straightforward. The package is compact and minimalistic, but also probably one of the easiest routers to set up.
+Just try it out for yourself, the usage of Router is very straightforward. The package is compact and minimalistic, but also probably one of the easiest routers to set up.
 
 ## Where can I find Middleware *X*?
 
@@ -204,13 +201,13 @@ The `NotFound` handler can for example be used to serve static files from the ro
 
 ```go
 // Serve static files from the ./public directory
-router.NotFound = fasthttp.FSHandler("./public", 0)
+r.NotFound = fasthttp.FSHandler("./public", 0)
 ```
 
 But this approach sidesteps the strict core rules of this router to avoid routing problems. A cleaner approach is to use a distinct sub-path for serving files, like `/static/*filepath` or `/files/*filepath`.
 
-## Web Frameworks based on FastHttpRouter
+## Web Frameworks based on Router
 
 If the HttpRouter is a bit too minimalistic for you, you might try one of the following more high-level 3rd-party web frameworks building upon the HttpRouter package:
 
-- Waiting for you to do this...
+- [Atreugo](https://github.com/savsgio/atreugo)

examples/auth/auth.go

@@ -71,9 +71,9 @@ func main() {
 	user := "gordon"
 	pass := "secret!"
 
-	router := router.New()
-	router.GET("/", Index)
-	router.GET("/protected/", BasicAuth(Protected, user, pass))
+	r := router.New()
+	r.GET("/", Index)
+	r.GET("/protected/", BasicAuth(Protected, user, pass))
 
-	log.Fatal(fasthttp.ListenAndServe(":8080", router.Handler))
+	log.Fatal(fasthttp.ListenAndServe(":8080", r.Handler))
 }

examples/basic/basic.go

@@ -32,11 +32,11 @@ func QueryArgs(ctx *fasthttp.RequestCtx) {
 }
 
 func main() {
-	router := router.New()
-	router.GET("/", Index)
-	router.GET("/hello/:name", Hello)
-	router.GET("/multi/:name/:word", MultiParams)
-	router.GET("/ping", QueryArgs)
+	r := router.New()
+	r.GET("/", Index)
+	r.GET("/hello/:name", Hello)
+	r.GET("/multi/:name/:word", MultiParams)
+	r.GET("/ping", QueryArgs)
 
-	log.Fatal(fasthttp.ListenAndServe(":8080", router.Handler))
+	log.Fatal(fasthttp.ListenAndServe(":8080", r.Handler))
 }

examples/hosts/hosts.go

@@ -37,14 +37,14 @@ func (hs HostSwitch) CheckHost(ctx *fasthttp.RequestCtx) {
 
 func main() {
 	// Initialize a router as usual
-	router := router.New()
-	router.GET("/", Index)
-	router.GET("/hello/:name", Hello)
+	r := router.New()
+	r.GET("/", Index)
+	r.GET("/hello/:name", Hello)
 
 	// Make a new HostSwitch and insert the router (our http handler)
 	// for example.com and port 12345
 	hs := make(HostSwitch)
-	hs["example.com:12345"] = router.Handler
+	hs["example.com:12345"] = r.Handler
 
 	// Use the HostSwitch to listen and serve on port 12345
 	log.Fatal(fasthttp.ListenAndServe(":12345", hs.CheckHost))

go.mod

@@ -2,5 +2,6 @@ module github.com/fasthttp/router
 
 require (
 	github.com/savsgio/gotils v0.0.0-20181102112957-636156ff2e0e
+	github.com/valyala/bytebufferpool v1.0.0
 	github.com/valyala/fasthttp v1.0.0
 )

go.sum

@@ -2,6 +2,7 @@ github.com/klauspost/compress v1.4.0 h1:8nsMz3tWa9SWWPL60G1V6CUsf4lLjWLTNEtibhe8
 github.com/klauspost/compress v1.4.0/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
 github.com/klauspost/cpuid v0.0.0-20180405133222-e7e905edc00e h1:+lIPJOWl+jSiJOc70QXJ07+2eg2Jy2EC7Mi11BWujeM=
 github.com/klauspost/cpuid v0.0.0-20180405133222-e7e905edc00e/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
+github.com/savsgio/gotils v0.0.0-20181102112957-636156ff2e0e h1:OaPrIuz2RcPhWlSWeV8mYrUzU3SNTIZAzkjhGfCU7bw=
 github.com/savsgio/gotils v0.0.0-20181102112957-636156ff2e0e/go.mod h1:w803/Fg1m0hrp1ZT9KNfQe4E4+WOMMFLcgzPvOcye10=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=

path.go

@@ -5,8 +5,51 @@
 
 package router
 
+import (
+	"sync"
+
+	"github.com/savsgio/gotils"
+)
+
+type cleanPathBuffer struct {
+	n        int
+	r        int
+	w        int
+	trailing bool
+	buf      []byte
+}
+
+var cleanPathBufferPool = sync.Pool{
+	New: func() interface{} {
+		return &cleanPathBuffer{
+			n:        0,
+			r:        0,
+			w:        1,
+			trailing: false,
+			buf:      make([]byte, 140),
+		}
+	},
+}
+
+func (cpb *cleanPathBuffer) reset() {
+	cpb.n = 0
+	cpb.r = 0
+	cpb.w = 1
+	cpb.trailing = false
+	// cpb.buf = cpb.buf[:0]
+}
+
+func acquireCleanPathBuffer() *cleanPathBuffer {
+	return cleanPathBufferPool.Get().(*cleanPathBuffer)
+}
+
+func releaseCleanPathBuffer(cpb *cleanPathBuffer) {
+	cpb.reset()
+	cleanPathBufferPool.Put(cpb)
+}
+
 // CleanPath is the URL version of path.Clean, it returns a canonical URL path
-// for p, eliminating . and .. elements.
+// for path, eliminating . and .. elements.
 //
 // The following rules are applied iteratively until no further processing can
 // be done:
@@ -18,106 +61,84 @@ package router
 //	   that is, replace "/.." by "/" at the beginning of a path.
 //
 // If the result of this process is an empty string, "/" is returned
-func CleanPath(p string) string {
-	// Turn empty string into "/"
-	if p == "" {
-		return "/"
-	}
+func CleanPath(path string) string {
+	cpb := acquireCleanPathBuffer()
+	cleanPathWithBuffer(cpb, path)
 
-	n := len(p)
-	var buf []byte
+	s := string(cpb.buf)
+	releaseCleanPathBuffer(cpb)
 
-	// Invariants:
-	//      reading from path; r is index of next byte to process.
-	//      writing to buf; w is index of next byte to write.
-
-	// path must start with '/'
-	r := 1
-	w := 1
+	return s
+}
 
-	if p[0] != '/' {
-		r = 0
-		buf = make([]byte, n+1)
-		buf[0] = '/'
+func cleanPathWithBuffer(cpb *cleanPathBuffer, path string) {
+	// Turn empty string into "/"
+	if path == "" {
+		cpb.buf = append(cpb.buf[:0], '/')
+		return
 	}
 
-	trailing := n > 2 && p[n-1] == '/'
+	cpb.n = len(path)
+	cpb.buf = gotils.ExtendByteSlice(cpb.buf, len(path)+1)
+	cpb.buf[0] = '/'
+
+	cpb.trailing = cpb.n > 2 && path[cpb.n-1] == '/'
 
 	// A bit more clunky without a 'lazybuf' like the path package, but the loop
 	// gets completely inlined (bufApp). So in contrast to the path package this
 	// loop has no expensive function calls (except 1x make)
 
-	for r < n {
+	for cpb.r < cpb.n {
+		// println(path[:cpb.r], " ####### ", string(path[cpb.r]), " ####### ", string(cpb.buf))
 		switch {
-		case p[r] == '/':
+		case path[cpb.r] == '/':
 			// empty path element, trailing slash is added after the end
-			r++
+			cpb.r++
 
-		case p[r] == '.' && r+1 == n:
-			trailing = true
-			r++
+		case path[cpb.r] == '.' && cpb.r+1 == cpb.n:
+			cpb.trailing = true
+			cpb.r++
 
-		case p[r] == '.' && p[r+1] == '/':
+		case path[cpb.r] == '.' && path[cpb.r+1] == '/':
 			// . element
-			r++
+			cpb.r++
 
-		case p[r] == '.' && p[r+1] == '.' && (r+2 == n || p[r+2] == '/'):
+		case path[cpb.r] == '.' && path[cpb.r+1] == '.' && (cpb.r+2 == cpb.n || path[cpb.r+2] == '/'):
 			// .. element: remove to last /
-			r += 2
+			cpb.r += 2
 
-			if w > 1 {
+			if cpb.w > 1 {
 				// can backtrack
-				w--
-
-				if buf == nil {
-					for w > 1 && p[w] != '/' {
-						w--
-					}
-				} else {
-					for w > 1 && buf[w] != '/' {
-						w--
-					}
+				cpb.w--
+
+				for cpb.w > 1 && cpb.buf[cpb.w] != '/' {
+					cpb.w--
 				}
+
 			}
 
 		default:
 			// real path element.
 			// add slash if needed
-			if w > 1 {
-				bufApp(&buf, p, w, '/')
-				w++
+			if cpb.w > 1 {
+				cpb.buf[cpb.w] = '/'
+				cpb.w++
 			}
 
 			// copy element
-			for r < n && p[r] != '/' {
-				bufApp(&buf, p, w, p[r])
-				w++
-				r++
+			for cpb.r < cpb.n && path[cpb.r] != '/' {
+				cpb.buf[cpb.w] = path[cpb.r]
+				cpb.w++
+				cpb.r++
 			}
 		}
 	}
 
 	// re-append trailing slash
-	if trailing && w > 1 {
-		bufApp(&buf, p, w, '/')
-		w++
+	if cpb.trailing && cpb.w > 1 {
+		cpb.buf[cpb.w] = '/'
+		cpb.w++
 	}
 
-	if buf == nil {
-		return p[:w]
-	}
-	return string(buf[:w])
-}
-
-// internal helper to lazily create a buffer if necessary
-func bufApp(buf *[]byte, s string, w int, c byte) {
-	if *buf == nil {
-		if s[w] == c {
-			return
-		}
-
-		*buf = make([]byte, len(s))
-		copy(*buf, s[:w])
-	}
-	(*buf)[w] = c
+	cpb.buf = cpb.buf[:cpb.w]
 }

path_test.go

@@ -66,10 +66,10 @@ var cleanTests = []struct {
 func TestPathClean(t *testing.T) {
 	for _, test := range cleanTests {
 		if s := CleanPath(test.path); s != test.result {
-			t.Errorf("CleanPath(%q) = %q, want %q", test.path, s, test.result)
+			t.Errorf("CleanPath(%s) = %s, want %s", test.path, s, test.result)
 		}
 		if s := CleanPath(test.result); s != test.result {
-			t.Errorf("CleanPath(%q) = %q, want %q", test.result, s, test.result)
+			t.Errorf("CleanPath(%s) = %s, want %s", test.result, s, test.result)
 		}
 	}
 }
@@ -90,3 +90,21 @@ func TestPathCleanMallocs(t *testing.T) {
 		}
 	}
 }
+
+func BenchmarkCleanPathWithBuffer(b *testing.B) {
+	path := "/../bench/"
+	cpb := acquireCleanPathBuffer()
+
+	for i := 0; i < b.N; i++ {
+		cleanPathWithBuffer(cpb, path)
+		cpb.reset()
+	}
+}
+
+func BenchmarkCleanPath(b *testing.B) {
+	path := "/../bench/"
+
+	for i := 0; i < b.N; i++ {
+		CleanPath(path)
+	}
+}