Move muxer into its own package

Author: Olivier Poitrey

README.md

@@ -73,28 +73,38 @@ func main() {
 }
 ```
 
-### Using muxer
+### Using xmux
 
-Xhandler comes with a context aware muxer forked from [httprouter](https://github.com/julienschmidt/httprouter):
+Xhandler comes with an optional context aware muxer forked from [httprouter](https://github.com/julienschmidt/httprouter):
 
 ```go
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/rs/xhandler"
+	"github.com/rs/xhandler/xmux"
+	"golang.org/x/net/context"
+)
+
 func main() {
-    c := xhandler.Chain{}
+	c := xhandler.Chain{}
 
 	// Append a context-aware middleware handler
 	c.UseC(xhandler.CloseHandler)
 
-	// Mix it with a non-context-aware middleware handler
-	c.Use(cors.Default().Handler)
-
 	// Another context-aware middleware handler
 	c.UseC(xhandler.TimeoutHandler(2 * time.Second))
 
-	mux := xhandler.NewMux()
+	mux := xmux.New()
 
 	// Use c.Handler to terminate the chain with your final handler
 	mux.GET("/welcome/:name", xhandler.HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, req *http.Request) {
-		fmt.Fprintf(w, "Welcome %s!", xhandler.URLParams(ctx).Get("name"))
+		fmt.Fprintf(w, "Welcome %s!", xmux.URLParams(ctx).Get("name"))
 	}))
 
 	if err := http.ListenAndServe(":8080", c.Handler(mux)); err != nil {

xhandler_test.go

@@ -13,6 +13,8 @@ import (
 
 type handler struct{}
 
+type key int
+
 const contextKey key = 0
 
 func newContext(ctx context.Context, value string) context.Context {

mux.go renamed to xmux/mux.go

@@ -1,13 +1,35 @@
-package xhandler
-
-import (
-	"net/http"
-
-	"golang.org/x/net/context"
-)
-
-// Mux is a xhandler.HandlerC which can be used to dispatch requests to different
-// handler functions via configurable routes
+// Package xmux is a net/context aware, tree based high performance HTTP request
+// multiplexer forked from httprouter.
+//
+// A trivial example is:
+//
+//  package main
+//
+//  import (
+//      "fmt"
+//      "net/http"
+//      "log"
+//
+//      "github.com/rs/xhandler"
+//      "github.com/rs/xhandler/xmux"
+//      "golang.org/x/net/context"
+//  )
+//
+//  func Index(ctx context.Context, w http.ResponseWriter, r *http.Request) {
+//      fmt.Fprint(w, "Welcome!\n")
+//  }
+//
+//  func Hello(ctx context.Context, w http.ResponseWriter, r *http.Request) {
+//      fmt.Fprintf(w, "hello, %s!\n", xmux.URLParams(ctx).Get("name"))
+//  }
+//
+//  func main() {
+//      mux := xmux.New()
+//      mux.GET("/", Index)
+//      mux.GET("/hello/:name", Hello)
+//
+//      log.Fatal(http.ListenAndServe(":8080", xhandler.New(context.Background(), mux)))
+//  }
 //
 // The muxer matches incoming requests by the request method and the path.
 // If a handle is registered for this path and method, the router delegates the
@@ -45,6 +67,18 @@ import (
 // The value of parameters is saved as aParams type saved into the context.
 // Parameters can be retrieved by name using xhandler.URLParams(ctx).Get(name) method:
 //  user := xhandler.URLParams(ctx).Get("user") // defined by :user or *user
+package xmux
+
+import (
+	"net/http"
+
+	"github.com/rs/xhandler"
+
+	"golang.org/x/net/context"
+)
+
+// Mux is a xhandler.HandlerC which can be used to dispatch requests to different
+// handler functions via configurable routes
 type Mux struct {
 	trees map[string]*node
 
@@ -76,12 +110,12 @@ type Mux struct {
 
 	// Configurable http.Handler which is called when no matching route is
 	// found. If it is not set, http.Error with http.StatusNotFound is used.
-	NotFound HandlerC
+	NotFound xhandler.HandlerC
 
 	// Configurable http.Handler which is called when a request
 	// cannot be routed and HandleMethodNotAllowed is true.
 	// If it is not set, http.Error with http.StatusMethodNotAllowed is used.
-	MethodNotAllowed HandlerC
+	MethodNotAllowed xhandler.HandlerC
 
 	// Function to handle panics recovered from http handlers.
 	// It should be used to generate a error page and return the http error code
@@ -131,8 +165,8 @@ func URLParams(ctx context.Context) Params {
 	return emptyParams
 }
 
-// NewMux returns a new muxer instance
-func NewMux() *Mux {
+// New returns a new muxer instance
+func New() *Mux {
 	return &Mux{
 		RedirectTrailingSlash:  true,
 		RedirectFixedPath:      true,
@@ -141,37 +175,37 @@ func NewMux() *Mux {
 }
 
 // GET is a shortcut for mux.Handle("GET", path, handler)
-func (mux *Mux) GET(path string, handler HandlerC) {
+func (mux *Mux) GET(path string, handler xhandler.HandlerC) {
 	mux.Handle("GET", path, handler)
 }
 
 // HEAD is a shortcut for mux.Handle("HEAD", path, handler)
-func (mux *Mux) HEAD(path string, handler HandlerC) {
+func (mux *Mux) HEAD(path string, handler xhandler.HandlerC) {
 	mux.Handle("HEAD", path, handler)
 }
 
 // OPTIONS is a shortcut for mux.Handle("OPTIONS", path, handler)
-func (mux *Mux) OPTIONS(path string, handler HandlerC) {
+func (mux *Mux) OPTIONS(path string, handler xhandler.HandlerC) {
 	mux.Handle("OPTIONS", path, handler)
 }
 
 // POST is a shortcut for mux.Handle("POST", path, handler)
-func (mux *Mux) POST(path string, handler HandlerC) {
+func (mux *Mux) POST(path string, handler xhandler.HandlerC) {
 	mux.Handle("POST", path, handler)
 }
 
 // PUT is a shortcut for mux.Handle("PUT", path, handler)
-func (mux *Mux) PUT(path string, handler HandlerC) {
+func (mux *Mux) PUT(path string, handler xhandler.HandlerC) {
 	mux.Handle("PUT", path, handler)
 }
 
 // PATCH is a shortcut for mux.Handle("PATCH", path, handler)
-func (mux *Mux) PATCH(path string, handler HandlerC) {
+func (mux *Mux) PATCH(path string, handler xhandler.HandlerC) {
 	mux.Handle("PATCH", path, handler)
 }
 
 // DELETE is a shortcut for mux.Handle("DELETE", path, handler)
-func (mux *Mux) DELETE(path string, handler HandlerC) {
+func (mux *Mux) DELETE(path string, handler xhandler.HandlerC) {
 	mux.Handle("DELETE", path, handler)
 }
 
@@ -183,7 +217,7 @@ func (mux *Mux) DELETE(path string, handler HandlerC) {
 // This function is intended for bulk loading and to allow the usage of less
 // frequently used, non-standardized or custom methods (e.g. for internal
 // communication with a proxy).
-func (mux *Mux) Handle(method, path string, handler HandlerC) {
+func (mux *Mux) Handle(method, path string, handler xhandler.HandlerC) {
 	if path[0] != '/' {
 		panic("path must begin with '/' in path '" + path + "'")
 	}
@@ -212,7 +246,7 @@ func (mux *Mux) recv(ctx context.Context, w http.ResponseWriter, r *http.Request
 // If the path was found, it returns the handle function and the path parameter
 // values. Otherwise the third return value indicates whether a redirection to
 // the same path with an extra / without the trailing slash should be performed.
-func (mux *Mux) Lookup(method, path string) (HandlerC, Params, bool) {
+func (mux *Mux) Lookup(method, path string) (xhandler.HandlerC, Params, bool) {
 	if root := mux.trees[method]; root != nil {
 		return root.getValue(path)
 	}

mux_bench_api_test.go renamed to xmux/mux_bench_api_test.go

@@ -1,11 +1,13 @@
 // Forked from https://github.com/julienschmidt/go-http-routing-benchmark
 //
-package xhandler
+package xmux
 
 import (
 	"net/http"
 	"testing"
 
+	"github.com/rs/xhandler"
+
 	"golang.org/x/net/context"
 )
 
@@ -56,21 +58,21 @@ var parseAPI = []route{
 }
 
 var (
-	parseXhandler   HandlerC
-	parseChi        HandlerC
+	parseXhandler   xhandler.HandlerC
+	parseChi        xhandler.HandlerC
 	parseGoji       http.Handler
 	parseHTTPRouter http.Handler
 )
 
-func getParseXhandler(b *testing.B) HandlerC {
+func getParseXhandler(b *testing.B) xhandler.HandlerC {
 	defer b.ResetTimer()
 	if parseXhandler == nil {
 		parseXhandler = loadXhandler(parseAPI)
 	}
 	return parseXhandler
 }
 
-func getParseChi(b *testing.B) HandlerC {
+func getParseChi(b *testing.B) xhandler.HandlerC {
 	defer b.ResetTimer()
 	if parseChi == nil {
 		parseChi = loadChi(parseAPI)

mux_bench_test.go renamed to xmux/mux_bench_test.go

@@ -1,6 +1,6 @@
 // Forked from https://github.com/julienschmidt/go-http-routing-benchmark
 //
-package xhandler
+package xmux
 
 import (
 	"io"
@@ -10,6 +10,7 @@ import (
 
 	"github.com/julienschmidt/httprouter"
 	"github.com/pressly/chi"
+	"github.com/rs/xhandler"
 	goji "github.com/zenazn/goji/web"
 	"golang.org/x/net/context"
 )
@@ -21,28 +22,28 @@ type route struct {
 	path   string
 }
 
-var httpHandlerC = HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {})
+var httpHandlerC = xhandler.HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {})
 
-var xhandlerWrite = HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
+var xhandlerWrite = xhandler.HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
 	io.WriteString(w, URLParams(ctx).Get("name"))
 })
 
-func loadXhandler(routes []route) HandlerC {
+func loadXhandler(routes []route) xhandler.HandlerC {
 	h := namedHandler{}
-	mux := NewMux()
+	mux := New()
 	for _, route := range routes {
 		mux.Handle(route.method, route.path, h)
 	}
 	return mux
 }
 
-func loadXhandlerSingle(method, path string, h HandlerC) HandlerC {
-	mux := NewMux()
+func loadXhandlerSingle(method, path string, h xhandler.HandlerC) xhandler.HandlerC {
+	mux := New()
 	mux.Handle(method, path, h)
 	return mux
 }
 
-func loadChi(routes []route) HandlerC {
+func loadChi(routes []route) xhandler.HandlerC {
 	h := namedHandler{}
 	router := chi.NewRouter()
 	for _, route := range routes {
@@ -64,7 +65,7 @@ func loadChi(routes []route) HandlerC {
 	return router
 }
 
-func loadChiSingle(method, path string, h HandlerC) HandlerC {
+func loadChiSingle(method, path string, h xhandler.HandlerC) xhandler.HandlerC {
 	router := chi.NewRouter()
 	switch method {
 	case "GET":
@@ -168,7 +169,7 @@ func benchRequest(b *testing.B, router http.Handler, r *http.Request) {
 	}
 }
 
-func benchRequestC(b *testing.B, router HandlerC, ctx context.Context, r *http.Request) {
+func benchRequestC(b *testing.B, router xhandler.HandlerC, ctx context.Context, r *http.Request) {
 	w := new(mockResponseWriter)
 	u := r.URL
 	rq := u.RawQuery
@@ -203,7 +204,7 @@ func benchRoutes(b *testing.B, router http.Handler, routes []route) {
 	}
 }
 
-func benchRoutesC(b *testing.B, router HandlerC, ctx context.Context, routes []route) {
+func benchRoutesC(b *testing.B, router xhandler.HandlerC, ctx context.Context, routes []route) {
 	w := new(mockResponseWriter)
 	r, _ := http.NewRequest("GET", "/", nil)
 	u := r.URL

mux_example_test.go renamed to xmux/mux_example_test.go

@@ -1,13 +1,13 @@
-package xhandler_test
+package xmux_test
 
 import (
 	"fmt"
 	"log"
 	"net/http"
 	"time"
 
-	"github.com/rs/cors"
 	"github.com/rs/xhandler"
+	"github.com/rs/xhandler/xmux"
 	"golang.org/x/net/context"
 )
 
@@ -17,17 +17,14 @@ func ExampleMux() {
 	// Append a context-aware middleware handler
 	c.UseC(xhandler.CloseHandler)
 
-	// Mix it with a non-context-aware middleware handler
-	c.Use(cors.Default().Handler)
-
 	// Another context-aware middleware handler
 	c.UseC(xhandler.TimeoutHandler(2 * time.Second))
 
-	mux := xhandler.NewMux()
+	mux := xmux.New()
 
 	// Use c.Handler to terminate the chain with your final handler
 	mux.GET("/welcome/:name", xhandler.HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, req *http.Request) {
-		fmt.Fprintf(w, "Welcome %s!", xhandler.URLParams(ctx).Get("name"))
+		fmt.Fprintf(w, "Welcome %s!", xmux.URLParams(ctx).Get("name"))
 	}))
 
 	if err := http.ListenAndServe(":8080", c.Handler(mux)); err != nil {