updated to use Go 1.7's *http.Request Context

- Remains backward compatible with 1.6
- See special notes section in README

Author: Dean Karn

README.md

@@ -1,6 +1,6 @@
 ##LARS
 <img align="right" src="https://raw.githubusercontent.com/go-playground/lars/master/examples/README/test.gif">
-![Project status](https://img.shields.io/badge/version-3.2.0-green.svg)
+![Project status](https://img.shields.io/badge/version-3.3.0-green.svg)
 [![Build Status](https://semaphoreci.com/api/v1/projects/4351aa2d-2f94-40be-a6ef-85c248490378/679708/badge.svg)](https://semaphoreci.com/joeybloggs/lars)
 [![Coverage Status](https://coveralls.io/repos/github/go-playground/lars/badge.svg?branch=master)](https://coveralls.io/github/go-playground/lars?branch=master)
 [![Go Report Card](https://goreportcard.com/badge/go-playground/lars)](https://goreportcard.com/report/go-playground/lars)
@@ -233,6 +233,26 @@ l.Use(nosurf.NewPure(lars.NativeChainHandler))
 // The functions are for convenience and are totally optional.
 ```
 
+Special Note
+-------------
+I don't know if it was an oversight or just an assumption about how middleware would be used with Go 1.7's new
+`context` integration into the `*http.Request` but there are a few quirks. As you know lars handles multiple handler
+types, including the native handler, this functionality is possible because of the way lar handles the middleware; lars
+does not `chain` the middleware in the normal way, but rather calles each in sequence; because of this all you have to 
+do is call c.Next() or it has already been wrapped to do so for you transparently. OK getting back to the point, if you
+are not using `lars.Context` to set the context information you will have to set the request object so that the information
+gets back to the calling package. eg.
+
+```go
+// because 'r' is a copy of a pointer to allow the information to get
+// back to the caller, need to set the value of 'r' as below with '*r'
+func(w http.ResponseWriter, r *http.Request) {
+	*r = *r.WithContext(context.WithValue(r.Context(), 0, "testval1"))
+}
+```
+
+this is not an issue specific to lars, but a quirk of the way `context` is tied to the `http.Request` object.
+
 Middleware
 -----------
 There are some pre-defined middlewares within the middleware folder; NOTE: that the middleware inside will
@@ -245,41 +265,40 @@ recovery middleware are very application dependent and therefore will be listed
 
 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.6 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 darwin/amd64
 
 NOTICE: lars uses a custom version of [httprouter](https://github.com/julienschmidt/httprouter), benchmarks can be found [here](https://github.com/joeybloggs/go-http-routing-benchmark/tree/lars-only)
 
 ```go
 go test -bench=. -benchmem=true
 #GithubAPI Routes: 203
-   LARS: 49040 Bytes
+   LARS: 49032 Bytes
 
 #GPlusAPI Routes: 13
-   LARS: 3648 Bytes
+   LARS: 3640 Bytes
 
 #ParseAPI Routes: 26
-   LARS: 6640 Bytes
+   LARS: 6632 Bytes
 
 #Static Routes: 157
-   LARS: 30128 Bytes
-
-PASS
-BenchmarkLARS_Param       	20000000	        77.1 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_Param5      	10000000	       134 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_Param20     	 5000000	       320 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_ParamWrite  	10000000	       142 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_GithubStatic	20000000	        96.2 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_GithubParam 	10000000	       156 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_GithubAll   	   50000	     32952 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_GPlusStatic 	20000000	        72.2 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_GPlusParam  	20000000	        98.0 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_GPlus2Params	10000000	       127 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_GPlusAll    	 1000000	      1619 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_ParseStatic 	20000000	        72.8 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_ParseParam  	20000000	        78.6 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_Parse2Params	20000000	        96.9 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_ParseAll    	  500000	      2968 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_StaticAll   	  100000	     22810 ns/op	       0 B/op	       0 allocs/op
+   LARS: 30120 Bytes
+
+BenchmarkLARS_Param            	20000000       	        70.2 ns/op     	       0 B/op  	       0 allocs/op
+BenchmarkLARS_Param5           	20000000       	       104 ns/op       	       0 B/op  	       0 allocs/op
+BenchmarkLARS_Param20          	 5000000       	       248 ns/op       	       0 B/op  	       0 allocs/op
+BenchmarkLARS_ParamWrite       	10000000       	       134 ns/op       	       0 B/op  	       0 allocs/op
+BenchmarkLARS_GithubStatic     	20000000       	        84.2 ns/op     	       0 B/op  	       0 allocs/op
+BenchmarkLARS_GithubParam      	10000000       	       129 ns/op       	       0 B/op  	       0 allocs/op
+BenchmarkLARS_GithubAll        	   50000       	     25334 ns/op       	       0 B/op  	       0 allocs/op
+BenchmarkLARS_GPlusStatic      	20000000       	        67.0 ns/op     	       0 B/op  	       0 allocs/op
+BenchmarkLARS_GPlusParam       	20000000       	        84.5 ns/op     	       0 B/op  	       0 allocs/op
+BenchmarkLARS_GPlus2Params     	20000000       	       103 ns/op       	       0 B/op  	       0 allocs/op
+BenchmarkLARS_GPlusAll         	 1000000       	      1135 ns/op       	       0 B/op  	       0 allocs/op
+BenchmarkLARS_ParseStatic      	20000000       	        67.5 ns/op     	       0 B/op  	       0 allocs/op
+BenchmarkLARS_ParseParam       	20000000       	        74.0 ns/op     	       0 B/op  	       0 allocs/op
+BenchmarkLARS_Parse2Params     	20000000       	        86.9 ns/op     	       0 B/op  	       0 allocs/op
+BenchmarkLARS_ParseAll         	 1000000       	      2029 ns/op       	       0 B/op  	       0 allocs/op
+BenchmarkLARS_StaticAll        	  100000       	     18157 ns/op       	       0 B/op  	       0 allocs/op
 ```
 
 Package Versioning

context.go

@@ -1,6 +1,7 @@
 package lars
 
 import (
+	"context"
 	"encoding/json"
 	"encoding/xml"
 	"io"
@@ -10,7 +11,6 @@ import (
 	"time"
 
 	"github.com/gorilla/websocket"
-	"golang.org/x/net/context"
 )
 
 // Param is a single URL parameter, consisting of a key and a value.
@@ -61,21 +61,6 @@ type Context interface {
 	BaseContext() *Ctx
 }
 
-// Ctx encapsulates the http request, response context
-type Ctx struct {
-	netContext          context.Context
-	request             *http.Request
-	response            *Response
-	websocket           *websocket.Conn
-	params              Params
-	handlers            HandlersChain
-	parent              Context
-	handlerName         string
-	index               int
-	formParsed          bool
-	multipartFormParsed bool
-}
-
 var _ context.Context = &Ctx{}
 
 // NewContext returns a new default lars Context object.
@@ -117,18 +102,6 @@ func (c *Ctx) WebSocket() *websocket.Conn {
 func (c *Ctx) RequestEnd() {
 }
 
-// RequestStart resets the Context to it's default request state
-func (c *Ctx) RequestStart(w http.ResponseWriter, r *http.Request) {
-	c.request = r
-	c.response.reset(w)
-	c.params = c.params[0:0]
-	c.netContext = context.Background() // in go 1.7 will call r.Context(), netContext will go away and be replaced with the Request objects Context
-	c.index = -1
-	c.handlers = nil
-	c.formParsed = false
-	c.multipartFormParsed = false
-}
-
 // Param returns the value of the first Param which key matches the given name.
 // If no matching Param is found, an empty string is returned.
 func (c *Ctx) Param(name string) string {
@@ -189,22 +162,6 @@ func (c *Ctx) ParseMultipartForm(maxMemory int64) error {
 	return nil
 }
 
-// Set is used to store a new key/value pair using the
-// golang.org/x/net/context contained on this Context.
-// It is a shortcut for context.WithValue(..., ...)
-func (c *Ctx) Set(key interface{}, value interface{}) {
-	c.netContext = context.WithValue(c.netContext, key, value)
-}
-
-// Get returns the value for the given key and is a shortcut
-// for the golang.org/x/net/context context.Value(...) ... but it
-// also returns if the value was found or not.
-func (c *Ctx) Get(key interface{}) (value interface{}, exists bool) {
-	value = c.netContext.Value(key)
-	exists = value != nil
-	return
-}
-
 // Next should be used only inside middleware.
 // It executes the pending handlers in the chain inside the calling handler.
 // See example in github.
@@ -457,67 +414,3 @@ func (c *Ctx) Decode(includeFormQueryParams bool, maxMemory int64, v interface{}
 	}
 	return
 }
-
-// golang.org/x/net/context functions to comply with context.Context interface and keep context update on lars.Context object
-
-// Context returns the request's context. To change the context, use
-// WithContext.
-//
-// The returned context is always non-nil.
-func (c *Ctx) Context() context.Context {
-	return c.netContext // TODO: in go 1.7 return c.request.Context()
-}
-
-// WithContext updates the underlying request's context with to ctx
-// The provided ctx must be non-nil.
-func (c *Ctx) WithContext(ctx context.Context) {
-	c.netContext = ctx // TODO: in go 1.7 must update Request object after calling c.request.WithContext(...)
-}
-
-// Deadline calls the underlying golang.org/x/net/context Deadline()
-func (c *Ctx) Deadline() (deadline time.Time, ok bool) {
-	return c.netContext.Deadline()
-}
-
-// Done calls the underlying golang.org/x/net/context Done()
-func (c *Ctx) Done() <-chan struct{} {
-	return c.netContext.Done()
-}
-
-// Err calls the underlying golang.org/x/net/context Err()
-func (c *Ctx) Err() error {
-	return c.netContext.Err()
-}
-
-// Value calls the underlying golang.org/x/net/context Value()
-func (c *Ctx) Value(key interface{}) interface{} {
-	return c.netContext.Value(key)
-}
-
-// WithCancel calls golang.org/x/net/context WithCancel and automatically
-// updates context on the containing las.Context object.
-func (c *Ctx) WithCancel() (cf context.CancelFunc) {
-	c.netContext, cf = context.WithCancel(c.netContext)
-	return
-}
-
-// WithDeadline calls golang.org/x/net/context WithDeadline and automatically
-// updates context on the containing las.Context object.
-func (c *Ctx) WithDeadline(deadline time.Time) (cf context.CancelFunc) {
-	c.netContext, cf = context.WithDeadline(c.netContext, deadline)
-	return
-}
-
-// WithTimeout calls golang.org/x/net/context WithTimeout and automatically
-// updates context on the containing las.Context object.
-func (c *Ctx) WithTimeout(timeout time.Duration) (cf context.CancelFunc) {
-	c.netContext, cf = context.WithTimeout(c.netContext, timeout)
-	return
-}
-
-// WithValue calls golang.org/x/net/context WithValue and automatically
-// updates context on the containing las.Context object.
-// Can also use Set() function on Context object (Recommended)
-func (c *Ctx) WithValue(key interface{}, val interface{}) {
-	c.netContext = context.WithValue(c.netContext, key, val)
-}

context_16.go

@@ -0,0 +1,118 @@
+// +build !go1.7
+
+package lars
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+// Ctx encapsulates the http request, response context
+type Ctx struct {
+	netContext          context.Context
+	request             *http.Request
+	response            *Response
+	websocket           *websocket.Conn
+	params              Params
+	handlers            HandlersChain
+	parent              Context
+	handlerName         string
+	index               int
+	formParsed          bool
+	multipartFormParsed bool
+}
+
+// RequestStart resets the Context to it's default request state
+func (c *Ctx) RequestStart(w http.ResponseWriter, r *http.Request) {
+	c.request = r
+	c.response.reset(w)
+	c.params = c.params[0:0]
+	c.netContext = context.Background() // in go 1.7 will call r.Context(), netContext will go away and be replaced with the Request objects Context
+	c.index = -1
+	c.handlers = nil
+	c.formParsed = false
+	c.multipartFormParsed = false
+}
+
+// Set is used to store a new key/value pair using the
+// golang.org/x/net/context contained on this Context.
+// It is a shortcut for context.WithValue(..., ...)
+func (c *Ctx) Set(key interface{}, value interface{}) {
+	c.netContext = context.WithValue(c.netContext, key, value)
+}
+
+// Get returns the value for the given key and is a shortcut
+// for the golang.org/x/net/context context.Value(...) ... but it
+// also returns if the value was found or not.
+func (c *Ctx) Get(key interface{}) (value interface{}, exists bool) {
+	value = c.netContext.Value(key)
+	exists = value != nil
+	return
+}
+
+// golang.org/x/net/context functions to comply with context.Context interface and keep context update on lars.Context object
+
+// Context returns the request's context. To change the context, use
+// WithContext.
+//
+// The returned context is always non-nil.
+func (c *Ctx) Context() context.Context {
+	return c.netContext // TODO: in go 1.7 return c.request.Context()
+}
+
+// WithContext updates the underlying request's context with to ctx
+// The provided ctx must be non-nil.
+func (c *Ctx) WithContext(ctx context.Context) {
+	c.netContext = ctx // TODO: in go 1.7 must update Request object after calling c.request.WithContext(...)
+}
+
+// Deadline calls the underlying golang.org/x/net/context Deadline()
+func (c *Ctx) Deadline() (deadline time.Time, ok bool) {
+	return c.netContext.Deadline()
+}
+
+// Done calls the underlying golang.org/x/net/context Done()
+func (c *Ctx) Done() <-chan struct{} {
+	return c.netContext.Done()
+}
+
+// Err calls the underlying golang.org/x/net/context Err()
+func (c *Ctx) Err() error {
+	return c.netContext.Err()
+}
+
+// Value calls the underlying golang.org/x/net/context Value()
+func (c *Ctx) Value(key interface{}) interface{} {
+	return c.netContext.Value(key)
+}
+
+// WithCancel calls golang.org/x/net/context WithCancel and automatically
+// updates context on the containing las.Context object.
+func (c *Ctx) WithCancel() (cf context.CancelFunc) {
+	c.netContext, cf = context.WithCancel(c.netContext)
+	return
+}
+
+// WithDeadline calls golang.org/x/net/context WithDeadline and automatically
+// updates context on the containing las.Context object.
+func (c *Ctx) WithDeadline(deadline time.Time) (cf context.CancelFunc) {
+	c.netContext, cf = context.WithDeadline(c.netContext, deadline)
+	return
+}
+
+// WithTimeout calls golang.org/x/net/context WithTimeout and automatically
+// updates context on the containing las.Context object.
+func (c *Ctx) WithTimeout(timeout time.Duration) (cf context.CancelFunc) {
+	c.netContext, cf = context.WithTimeout(c.netContext, timeout)
+	return
+}
+
+// WithValue calls golang.org/x/net/context WithValue and automatically
+// updates context on the containing las.Context object.
+// Can also use Set() function on Context object (Recommended)
+func (c *Ctx) WithValue(key interface{}, val interface{}) {
+	c.netContext = context.WithValue(c.netContext, key, val)
+}