Merge branch 'add-unmarshal-logic'

Author: joeybloggs

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.0-green.svg)
+![Project status](https://img.shields.io/badge/version-3.1-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)
@@ -179,6 +179,19 @@ func Home(c *MyContext) {
 }
 ```
 
+Decoding Body
+-------------
+For full example see [here](https://github.com/go-playground/lars/blob/master/examples/decode/main.go).
+currently JSON, XML, FORM + Multipart Form's are support out of the box.
+```go
+	// first argument denotes yes or no I would like URL query parameter fields
+	// to be included. i.e. 'id' in route '/user/:id' should it be included.
+	// run, then change to false and you'll see user.ID is not populated.
+	if err := c.Decode(true, maxBytes, &user); err != nil {
+		log.Println(err)
+	}
+```
+
 Misc
 -----
 ```go

context.go

@@ -57,6 +57,7 @@ type Context interface {
 	TextBytes(int, []byte) error
 	Attachment(r io.Reader, filename string) (err error)
 	Inline(r io.Reader, filename string) (err error)
+	Decode(includeFormQueryParams bool, maxMemory int64, v interface{}) (err error)
 	BaseContext() *Ctx
 }
 
@@ -73,6 +74,7 @@ type Ctx struct {
 	index               int
 	formParsed          bool
 	multipartFormParsed bool
+	l                   *LARS
 }
 
 var _ context.Context = &Ctx{}
@@ -82,6 +84,7 @@ func NewContext(l *LARS) *Ctx {
 
 	c := &Ctx{
 		params: make(Params, l.mostParams),
+		l:      l,
 	}
 
 	c.response = newResponse(nil, c)
@@ -412,6 +415,51 @@ func (c *Ctx) Inline(r io.Reader, filename string) (err error) {
 	return
 }
 
+// Decode takes the request and attempts to discover it's content type via
+// the http headers and then decode the request body into the provided struct.
+// Example if header was "application/json" would decode using
+// json.NewDecoder(io.LimitReader(c.request.Body, maxMemory)).Decode(v).
+func (c *Ctx) Decode(includeFormQueryParams bool, maxMemory int64, v interface{}) (err error) {
+
+	c.l.initFormDecoder()
+
+	typ := c.request.Header.Get(ContentType)
+
+	if idx := strings.Index(typ, ";"); idx != -1 {
+		typ = typ[:idx]
+	}
+
+	switch typ {
+
+	case ApplicationJSON:
+		err = json.NewDecoder(io.LimitReader(c.request.Body, maxMemory)).Decode(v)
+
+	case ApplicationXML:
+		err = xml.NewDecoder(io.LimitReader(c.request.Body, maxMemory)).Decode(v)
+
+	case ApplicationForm:
+
+		if err = c.ParseForm(); err == nil {
+			if includeFormQueryParams {
+				err = c.l.formDecoder.Decode(v, c.request.Form)
+			} else {
+				err = c.l.formDecoder.Decode(v, c.request.PostForm)
+			}
+		}
+
+	case MultipartForm:
+
+		if err = c.ParseMultipartForm(maxMemory); err == nil {
+			if includeFormQueryParams {
+				err = c.l.formDecoder.Decode(v, c.request.Form)
+			} else {
+				err = c.l.formDecoder.Decode(v, c.request.MultipartForm.Value)
+			}
+		}
+	}
+	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

context_test.go

@@ -1,12 +1,16 @@
 package lars
 
 import (
+	"bytes"
 	"encoding/xml"
 	"io"
+	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
+	"net/url"
 	"os"
 	"reflect"
+	"strings"
 	"testing"
 	"time"
 
@@ -26,6 +30,127 @@ import (
 // go test -coverprofile cover.out && go tool cover -html=cover.out -o cover.html
 //
 
+func TestDecode(t *testing.T) {
+
+	type TestStruct struct {
+		ID              int `form:"id"`
+		Posted          string
+		MultiPartPosted string
+	}
+
+	test := new(TestStruct)
+
+	l := New()
+	l.Post("/decode/:id", func(c Context) {
+		err := c.Decode(true, 16<<10, test)
+		Equal(t, err, nil)
+	})
+	l.Post("/decode2/:id", func(c Context) {
+		err := c.Decode(false, 16<<10, test)
+		Equal(t, err, nil)
+	})
+
+	NotEqual(t, l.BuiltInFormDecoder(), nil)
+
+	hf := l.Serve()
+
+	form := url.Values{}
+	form.Add("Posted", "value")
+
+	r, _ := http.NewRequest(POST, "/decode/13", strings.NewReader(form.Encode()))
+	r.Header.Set(ContentType, ApplicationForm)
+	w := httptest.NewRecorder()
+
+	hf.ServeHTTP(w, r)
+
+	Equal(t, w.Code, http.StatusOK)
+	Equal(t, test.ID, 13)
+	Equal(t, test.Posted, "value")
+	Equal(t, test.MultiPartPosted, "")
+
+	test = new(TestStruct)
+	r, _ = http.NewRequest(POST, "/decode2/13", strings.NewReader(form.Encode()))
+	r.Header.Set(ContentType, ApplicationForm)
+	w = httptest.NewRecorder()
+
+	hf.ServeHTTP(w, r)
+
+	Equal(t, w.Code, http.StatusOK)
+	Equal(t, test.ID, 0)
+	Equal(t, test.Posted, "value")
+	Equal(t, test.MultiPartPosted, "")
+
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+
+	err := writer.WriteField("MultiPartPosted", "value")
+	Equal(t, err, nil)
+
+	// Don't forget to close the multipart writer.
+	// If you don't close it, your request will be missing the terminating boundary.
+	err = writer.Close()
+	Equal(t, err, nil)
+
+	test = new(TestStruct)
+	r, _ = http.NewRequest(POST, "/decode/13", body)
+	r.Header.Set(ContentType, writer.FormDataContentType())
+	w = httptest.NewRecorder()
+
+	hf.ServeHTTP(w, r)
+	Equal(t, w.Code, http.StatusOK)
+	Equal(t, test.ID, 13)
+	Equal(t, test.Posted, "")
+	Equal(t, test.MultiPartPosted, "value")
+
+	body = &bytes.Buffer{}
+	writer = multipart.NewWriter(body)
+
+	err = writer.WriteField("MultiPartPosted", "value")
+	Equal(t, err, nil)
+
+	// Don't forget to close the multipart writer.
+	// If you don't close it, your request will be missing the terminating boundary.
+	err = writer.Close()
+	Equal(t, err, nil)
+
+	test = new(TestStruct)
+	r, _ = http.NewRequest(POST, "/decode2/13", body)
+	r.Header.Set(ContentType, writer.FormDataContentType())
+	w = httptest.NewRecorder()
+
+	hf.ServeHTTP(w, r)
+	Equal(t, w.Code, http.StatusOK)
+	Equal(t, test.ID, 0)
+	Equal(t, test.Posted, "")
+	Equal(t, test.MultiPartPosted, "value")
+
+	jsonBody := `{"ID":13,"Posted":"value","MultiPartPosted":"value"}`
+	test = new(TestStruct)
+	r, _ = http.NewRequest(POST, "/decode/13", strings.NewReader(jsonBody))
+	r.Header.Set(ContentType, ApplicationJSON)
+	w = httptest.NewRecorder()
+
+	hf.ServeHTTP(w, r)
+
+	Equal(t, w.Code, http.StatusOK)
+	Equal(t, test.ID, 13)
+	Equal(t, test.Posted, "value")
+	Equal(t, test.MultiPartPosted, "value")
+
+	xmlBody := `<TestStruct><ID>13</ID><Posted>value</Posted><MultiPartPosted>value</MultiPartPosted></TestStruct>`
+	test = new(TestStruct)
+	r, _ = http.NewRequest(POST, "/decode/13", strings.NewReader(xmlBody))
+	r.Header.Set(ContentType, ApplicationXML)
+	w = httptest.NewRecorder()
+
+	hf.ServeHTTP(w, r)
+
+	Equal(t, w.Code, http.StatusOK)
+	Equal(t, test.ID, 13)
+	Equal(t, test.Posted, "value")
+	Equal(t, test.MultiPartPosted, "value")
+}
+
 func TestStream(t *testing.T) {
 	l := New()
 

doc.go

@@ -152,6 +152,19 @@ example context + custom handlers
 		...
 	}
 
+Decoding Body
+
+For full example see https://github.com/go-playground/lars/blob/master/examples/decode/main.go
+currently JSON, XML, FORM + Multipart Form's are support out of the box.
+
+	// first argument denotes yes or no I would like URL query parameter fields
+	// to be included. i.e. 'id' in route '/user/:id' should it be included.
+	// run, then change to false and you'll see user.ID is not populated.
+	if err := c.Decode(true, maxBytes, &user); err != nil {
+		log.Println(err)
+	}
+
+
 Misc
 
 misc examples and noteworthy features

examples/decode/main.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"log"
+	"net/http"
+	"net/url"
+	"time"
+
+	"github.com/go-playground/lars"
+)
+
+const (
+	// used for io.LimitReader(...) for safetly!
+	maxBytes = 16 << 10
+)
+
+// User ...
+type User struct {
+	ID   int `form:"id"`
+	Name string
+}
+
+func main() {
+
+	l := lars.New()
+	l.Post("/user/:id", PostUser)
+
+	go simulateFormPost()
+
+	http.ListenAndServe(":3007", l.Serve())
+}
+
+// PostUser ...
+func PostUser(c lars.Context) {
+	var user User
+
+	// first argument denotes yes or no I would like URL query parameter fields
+	// to be included. i.e. 'id' in route '/user/:id' should it be included.
+	// run, then change to false and you'll see user.ID is not populated.
+	if err := c.Decode(true, maxBytes, &user); err != nil {
+		log.Println(err)
+	}
+
+	log.Printf("%#v", user)
+}
+
+func simulateFormPost() {
+	time.Sleep(1000)
+	http.PostForm("http://localhost:3007/user/13", url.Values{"Name": {"joeybloggs"}})
+}

lars.go

@@ -6,6 +6,8 @@ import (
 	"reflect"
 	"strings"
 	"sync"
+
+	"github.com/go-playground/form"
 )
 
 // HTTP Constant Terms and Variables
@@ -150,6 +152,10 @@ type LARS struct {
 	// if enabled automatically handles OPTION requests; manually configured OPTION
 	// handlers take precidence. default true
 	automaticallyHandleOPTIONS bool
+
+	// form decoder + once initialization
+	formDecoder     *form.Decoder
+	formDecoderInit sync.Once
 }
 
 // RouteMap contains a single routes full path
@@ -207,6 +213,21 @@ func New() *LARS {
 	return l
 }
 
+// BuiltInFormDecoder returns the built in form decoder github.com/go-playground/form
+// in order for custom type to be registered.
+func (l *LARS) BuiltInFormDecoder() *form.Decoder {
+
+	l.initFormDecoder()
+
+	return l.formDecoder
+}
+
+func (l *LARS) initFormDecoder() {
+	l.formDecoderInit.Do(func() {
+		l.formDecoder = form.NewDecoder()
+	})
+}
+
 // RegisterCustomHandler registers a custom handler that gets wrapped by HandlerFunc
 func (l *LARS) RegisterCustomHandler(customType interface{}, fn CustomHandlerFunc) {