Merge branch 'minor-additions-and-improvements'

Author: Dean Karn

README.md

@@ -1,6 +1,6 @@
 ##Pure
 <img align="right" src="https://raw.githubusercontent.com/go-playground/pure/master/logo.png">
-![Project status](https://img.shields.io/badge/version-3.0.1-green.svg)
+![Project status](https://img.shields.io/badge/version-3.1.0-green.svg)
 [![Build Status](https://semaphoreci.com/api/v1/joeybloggs/pure/branches/master/badge.svg)](https://semaphoreci.com/joeybloggs/pure)
 [![Coverage Status](https://coveralls.io/repos/github/go-playground/pure/badge.svg?branch=master)](https://coveralls.io/github/go-playground/pure?branch=master)
 [![Go Report Card](https://goreportcard.com/badge/github.com/go-playground/pure)](https://goreportcard.com/report/github.com/go-playground/pure)
@@ -116,7 +116,8 @@ admin.Use(SomeAdminSecurityMiddleware)
 
 Decoding Body
 -------------
-currently JSON, XML, FORM, Multipart Form and url.Values are support out of the box.
+currently JSON, XML, FORM, Multipart Form and url.Values are support out of the box; there are also 
+individual functions for each as well when you know the Content-Type.
 ```go
 	// second argument denotes yes or no I would like URL query parameter fields
 	// to be included. i.e. 'id' and 'id2' in route '/user/:id?id2=val' should it be included.
@@ -155,40 +156,40 @@ Other middleware will be listed under the examples/middleware/... folder for a q
 
 Benchmarks
 -----------
-Run on MacBook Pro (Retina, 15-inch, Late 2013) 2.6 GHz Intel Core i7 16 GB 1600 MHz DDR3 using Go version go1.7.3 darwin/amd64
+Run on MacBook Pro (Retina, 15-inch, Late 2013) 2.6 GHz Intel Core i7 16 GB 1600 MHz DDR3 using Go version go1.7.4 darwin/amd64
 
 NOTICE: pure uses a custom version of [httprouter](https://github.com/julienschmidt/httprouter)'s radix tree, benchmarks can be found [here](https://github.com/joeybloggs/go-http-routing-benchmark/tree/pure-and-lars) the slowdown is with the use of the `context` package, as you can see when no SEO params are defined, and therefore no need to store anything in the context, it is faster than even lars.
 
 ```go
 go test -bench=. -benchmem=true
 #GithubAPI Routes: 203
-   Pure: 37560 Bytes
+   Pure: 37544 Bytes
 
 #GPlusAPI Routes: 13
-   Pure: 2808 Bytes
+   Pure: 2792 Bytes
 
 #ParseAPI Routes: 26
-   Pure: 5072 Bytes
+   Pure: 5056 Bytes
 
 #Static Routes: 157
-   Pure: 21224 Bytes
-
-BenchmarkPure_Param        	10000000	       156 ns/op	     240 B/op	       1 allocs/op
-BenchmarkPure_Param5       	10000000	       199 ns/op	     240 B/op	       1 allocs/op
-BenchmarkPure_Param20      	 5000000	       349 ns/op	     240 B/op	       1 allocs/op
-BenchmarkPure_ParamWrite   	10000000	       209 ns/op	     240 B/op	       1 allocs/op
-BenchmarkPure_GithubStatic 	30000000	        45.4 ns/op	       0 B/op	       0 allocs/op
-BenchmarkPure_GithubParam  	10000000	       219 ns/op	     240 B/op	       1 allocs/op
-BenchmarkPure_GithubAll    	   30000	     40244 ns/op	   40082 B/op	     167 allocs/op
-BenchmarkPure_GPlusStatic  	50000000	        30.4 ns/op	       0 B/op	       0 allocs/op
-BenchmarkPure_GPlusParam   	10000000	       173 ns/op	     240 B/op	       1 allocs/op
-BenchmarkPure_GPlus2Params 	10000000	       190 ns/op	     240 B/op	       1 allocs/op
-BenchmarkPure_GPlusAll     	 1000000	      2108 ns/op	    2640 B/op	      11 allocs/op
-BenchmarkPure_ParseStatic  	50000000	        29.9 ns/op	       0 B/op	       0 allocs/op
-BenchmarkPure_ParseParam   	10000000	       154 ns/op	     240 B/op	       1 allocs/op
-BenchmarkPure_Parse2Params 	10000000	       167 ns/op	     240 B/op	       1 allocs/op
-BenchmarkPure_ParseAll     	  500000	      3209 ns/op	    3840 B/op	      16 allocs/op
-BenchmarkPure_StaticAll    	  200000	      9881 ns/op	       0 B/op	       0 allocs/op
+   Pure: 21208 Bytes
+
+BenchmarkPure_Param        	10000000	       159 ns/op	     240 B/op	       1 allocs/op
+BenchmarkPure_Param5       	10000000	       207 ns/op	     240 B/op	       1 allocs/op
+BenchmarkPure_Param20      	 5000000	       353 ns/op	     240 B/op	       1 allocs/op
+BenchmarkPure_ParamWrite   	10000000	       224 ns/op	     240 B/op	       1 allocs/op
+BenchmarkPure_GithubStatic 	30000000	        47.0 ns/op	       0 B/op	       0 allocs/op
+BenchmarkPure_GithubParam  	10000000	       226 ns/op	     240 B/op	       1 allocs/op
+BenchmarkPure_GithubAll    	   30000	     41178 ns/op	   40082 B/op	     167 allocs/op
+BenchmarkPure_GPlusStatic  	50000000	        30.1 ns/op	       0 B/op	       0 allocs/op
+BenchmarkPure_GPlusParam   	10000000	       172 ns/op	     240 B/op	       1 allocs/op
+BenchmarkPure_GPlus2Params 	10000000	       192 ns/op	     240 B/op	       1 allocs/op
+BenchmarkPure_GPlusAll     	 1000000	      2127 ns/op	    2640 B/op	      11 allocs/op
+BenchmarkPure_ParseStatic  	50000000	        30.0 ns/op	       0 B/op	       0 allocs/op
+BenchmarkPure_ParseParam   	10000000	       165 ns/op	     240 B/op	       1 allocs/op
+BenchmarkPure_Parse2Params 	10000000	       177 ns/op	     240 B/op	       1 allocs/op
+BenchmarkPure_ParseAll     	  500000	      3298 ns/op	    3840 B/op	      16 allocs/op
+BenchmarkPure_StaticAll    	  200000	      9685 ns/op	       0 B/op	       0 allocs/op
 ```
 
 Package Versioning

helpers.go

@@ -264,54 +264,112 @@ func Decode(r *http.Request, includeQueryParams bool, maxMemory int64, v interfa
 	switch typ {
 
 	case ApplicationJSON:
+		err = DecodeJSON(r, includeQueryParams, maxMemory, v)
 
-		err = json.NewDecoder(io.LimitReader(r.Body, maxMemory)).Decode(v)
+	case ApplicationXML:
+		err = DecodeXML(r, includeQueryParams, maxMemory, v)
 
-		if includeQueryParams && err == nil {
-			err = DecodeQueryParams(r, includeQueryParams, v)
-		}
+	case ApplicationForm:
+		err = DecodeForm(r, includeQueryParams, v)
 
-	case ApplicationXML:
+	case MultipartForm:
+		err = DecodeMultipartForm(r, includeQueryParams, maxMemory, v)
 
-		err = xml.NewDecoder(io.LimitReader(r.Body, maxMemory)).Decode(v)
+	case ApplicationQueryParams:
 
-		if includeQueryParams && err == nil {
+		if includeQueryParams {
 			err = DecodeQueryParams(r, includeQueryParams, v)
 		}
+	}
 
-	case ApplicationForm:
+	return
+}
 
-		if includeQueryParams {
+// DecodeForm parses the requests form data into the provided struct.
+//
+// The Content-Type and http method are not checked.
+//
+// NOTE: when includeQueryParams=true both query params and SEO query params will be parsed and
+// included eg. route /user/:id?test=true both 'id' and 'test' are treated as query params and added
+// to the request.Form prior to decoding; in short SEO query params are treated just like normal query params.
+func DecodeForm(r *http.Request, includeQueryParams bool, v interface{}) (err error) {
 
-			if err = ParseForm(r); err == nil {
-				err = DefaultDecoder.Decode(v, r.Form)
-			}
+	if includeQueryParams {
 
-		} else {
-			if err = r.ParseForm(); err == nil {
-				err = DefaultDecoder.Decode(v, r.PostForm)
-			}
+		if err = ParseForm(r); err == nil {
+			err = DefaultDecoder.Decode(v, r.Form)
 		}
 
-	case MultipartForm:
+		return
+	}
 
-		if includeQueryParams {
+	if err = r.ParseForm(); err == nil {
+		err = DefaultDecoder.Decode(v, r.PostForm)
+	}
 
-			if err = ParseMultipartForm(r, maxMemory); err == nil {
-				err = DefaultDecoder.Decode(v, r.Form)
-			}
+	return
+}
 
-		} else {
-			if err = r.ParseMultipartForm(maxMemory); err == nil {
-				err = DefaultDecoder.Decode(v, r.MultipartForm.Value)
-			}
-		}
+// DecodeForm parses the requests form data into the provided struct.
+//
+// The Content-Type and http method are not checked.
+//
+// NOTE: when includeQueryParams=true both query params and SEO query params will be parsed and
+// included eg. route /user/:id?test=true both 'id' and 'test' are treated as query params and added
+// to the request.Form prior to decoding; in short SEO query params are treated just like normal query params.
+func DecodeMultipartForm(r *http.Request, includeQueryParams bool, maxMemory int64, v interface{}) (err error) {
 
-	case ApplicationQueryParams:
-		if includeQueryParams {
-			err = DecodeQueryParams(r, includeQueryParams, v)
+	if includeQueryParams {
+
+		if err = ParseMultipartForm(r, maxMemory); err == nil {
+			err = DefaultDecoder.Decode(v, r.Form)
 		}
+
+		return
 	}
+
+	if err = r.ParseMultipartForm(maxMemory); err == nil {
+		err = DefaultDecoder.Decode(v, r.MultipartForm.Value)
+	}
+
+	return
+}
+
+// DecodeJSON decodes the request body into the provided struct and limits the request size via
+// an io.LimitReader using the maxMemory param.
+//
+// The Content-Type e.g. "application/json" and http method are not checked.
+//
+// NOTE: when includeQueryParams=true both query params and SEO query params will be parsed and
+// included eg. route /user/:id?test=true both 'id' and 'test' are treated as query params and
+// added to parsed JSON; in short SEO query params are treated just like normal query params.
+func DecodeJSON(r *http.Request, includeQueryParams bool, maxMemory int64, v interface{}) (err error) {
+
+	err = json.NewDecoder(io.LimitReader(r.Body, maxMemory)).Decode(v)
+
+	if includeQueryParams && err == nil {
+		err = DecodeQueryParams(r, includeQueryParams, v)
+	}
+
+	return
+}
+
+// DecodeXML decodes the request body into the provided struct and limits the request size via
+// an io.LimitReader using the maxMemory param.
+//
+// The Content-Type e.g. "application/xml" and http method are not checked.
+//
+// NOTE: when includeQueryParams=true both query params and SEO query params will be parsed and
+// included eg. route /user/:id?test=true both 'id' and 'test' are treated as query params and
+// added to parsed XML; in short SEO query params are treated just like normal query params.
+func DecodeXML(r *http.Request, includeQueryParams bool, maxMemory int64, v interface{}) (err error) {
+
+	err = xml.NewDecoder(io.LimitReader(r.Body, maxMemory)).Decode(v)
+
+	if includeQueryParams && err == nil {
+		err = DecodeQueryParams(r, includeQueryParams, v)
+	}
+
 	return
 }
 

node.go

@@ -49,11 +49,9 @@ func (n *node) incrementChildPrio(pos int) int {
 	// adjust position (move to front)
 	newPos := pos
 	for newPos > 0 && n.children[newPos-1].priority < prio {
-		// swap node positions
-		tmpN := n.children[newPos-1]
-		n.children[newPos-1] = n.children[newPos]
-		n.children[newPos] = tmpN
 
+		// swap node positions
+		n.children[newPos-1], n.children[newPos] = n.children[newPos], n.children[newPos-1]
 		newPos--
 	}
 

pure.go

@@ -32,15 +32,15 @@ type Mux struct {
 	// pool is used for reusable request scoped RequestVars content
 	pool sync.Pool
 
+	http404     http.HandlerFunc // 404 Not Found
+	http405     http.HandlerFunc // 405 Method Not Allowed
+	httpOPTIONS http.HandlerFunc
+
 	// mostParams used to keep track of the most amount of
 	// params in any URL and this will set the default capacity
 	// of each Params
 	mostParams uint8
 
-	http404     http.HandlerFunc // 404 Not Found
-	http405     http.HandlerFunc // 405 Method Not Allowed
-	httpOPTIONS http.HandlerFunc
-
 	// Enables automatic redirection if the current route can't be matched but a
 	// handler for the path with (without) the trailing slash exists.
 	// For example if /foo/ is requested but a route only exists for /foo, the

pure_test.go

@@ -27,17 +27,23 @@ import (
 
 var (
 	defaultHandler = func(w http.ResponseWriter, r *http.Request) {
-		w.Write([]byte(r.Method))
+		if _, err := w.Write([]byte(r.Method)); err != nil {
+			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		}
 	}
 
 	idHandler = func(w http.ResponseWriter, r *http.Request) {
 		rv := RequestVars(r)
-		w.Write([]byte(rv.URLParam("id")))
+		if _, err := w.Write([]byte(rv.URLParam("id"))); err != nil {
+			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		}
 	}
 
 	params2Handler = func(w http.ResponseWriter, r *http.Request) {
 		rv := RequestVars(r)
-		w.Write([]byte(rv.URLParam("p1") + "|" + rv.URLParam("p2")))
+		if _, err := w.Write([]byte(rv.URLParam("p1") + "|" + rv.URLParam("p2"))); err != nil {
+			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		}
 	}
 
 	defaultMiddleware = func(next http.HandlerFunc) http.HandlerFunc {