Add new helper functions

1. Add ParseForm(...) & ParseMultiPartForm(...) functions that also add the SEO params to the parsed Form eg. /users/:id, 'id' will be added to the request.Form just like normal query params would be.
2. Modify Decode(...) function to use the new #1 functions when inCludeQueryParams=true

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-1.0.0-green.svg)
+![Project status](https://img.shields.io/badge/version-1.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)

helpers.go

@@ -190,10 +190,68 @@ func XMLBytes(w http.ResponseWriter, status int, b []byte) (err error) {
 	return
 }
 
+// ParseForm calls the underlying http.Request ParseForm
+// but also adds the URL params to the request Form as if
+// they were defined as query params i.e. ?id=13&ok=true but
+// does not add the params to the http.Request.URL.RawQuery
+// for SEO purposes
+func ParseForm(r *http.Request) error {
+
+	if err := r.ParseForm(); err != nil {
+		return err
+	}
+
+	if rvi := r.Context().Value(defaultContextIdentifier); rvi != nil {
+
+		rv := rvi.(*requestVars)
+
+		if !rv.formParsed {
+			for _, p := range rv.params {
+				r.Form.Add(p.Key, p.Value)
+			}
+
+			rv.formParsed = true
+		}
+	}
+
+	return nil
+}
+
+// ParseMultipartForm calls the underlying http.Request ParseMultipartForm
+// but also adds the URL params to the request Form as if they were defined
+// as query params i.e. ?id=13&ok=true but does not add the params to the
+// http.Request.URL.RawQuery for SEO purposes
+func ParseMultipartForm(r *http.Request, maxMemory int64) error {
+
+	if err := r.ParseMultipartForm(maxMemory); err != nil {
+		return err
+	}
+
+	if rvi := r.Context().Value(defaultContextIdentifier); rvi != nil {
+
+		rv := rvi.(*requestVars)
+
+		if !rv.formParsed {
+			for _, p := range rv.params {
+				r.Form.Add(p.Key, p.Value)
+			}
+
+			rv.formParsed = true
+		}
+	}
+
+	return nil
+}
+
 // 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(r.Body, maxMemory)).Decode(v).
+//
+// NOTE: when includeFormQueryParams=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 Decode(r *http.Request, includeFormQueryParams bool, maxMemory int64, v interface{}) (err error) {
 
 	typ := r.Header.Get(ContentType)
@@ -212,20 +270,28 @@ func Decode(r *http.Request, includeFormQueryParams bool, maxMemory int64, v int
 
 	case ApplicationForm:
 
-		if err = r.ParseForm(); err == nil {
-			if includeFormQueryParams {
+		if includeFormQueryParams {
+
+			if err = ParseForm(r); err == nil {
 				err = DefaultDecoder.Decode(v, r.Form)
-			} else {
+			}
+
+		} else {
+			if err = r.ParseForm(); err == nil {
 				err = DefaultDecoder.Decode(v, r.PostForm)
 			}
 		}
 
 	case MultipartForm:
 
-		if err = r.ParseMultipartForm(maxMemory); err == nil {
-			if includeFormQueryParams {
+		if includeFormQueryParams {
+
+			if err = ParseMultipartForm(r, maxMemory); err == nil {
 				err = DefaultDecoder.Decode(v, r.Form)
-			} else {
+			}
+
+		} else {
+			if err = r.ParseMultipartForm(maxMemory); err == nil {
 				err = DefaultDecoder.Decode(v, r.MultipartForm.Value)
 			}
 		}

helpers_test.go

@@ -88,13 +88,17 @@ func TestDecode(t *testing.T) {
 		err := Decode(r, false, 16<<10, test)
 		Equal(t, err, nil)
 	})
+	p.Post("/decode3/:id", func(w http.ResponseWriter, r *http.Request) {
+		err := Decode(r, true, 16<<10, test)
+		Equal(t, err, nil)
+	})
 
 	hf := p.Serve()
 
 	form := url.Values{}
 	form.Add("Posted", "value")
 
-	r, _ := http.NewRequest(http.MethodPost, "/decode/13?id=13", strings.NewReader(form.Encode()))
+	r, _ := http.NewRequest(http.MethodPost, "/decode/14?id=13", strings.NewReader(form.Encode()))
 	r.Header.Set(ContentType, ApplicationForm)
 	w := httptest.NewRecorder()
 
@@ -105,6 +109,17 @@ func TestDecode(t *testing.T) {
 	Equal(t, test.Posted, "value")
 	Equal(t, test.MultiPartPosted, "")
 
+	r, _ = http.NewRequest(http.MethodPost, "/decode/14", 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, 14)
+	Equal(t, test.Posted, "value")
+	Equal(t, test.MultiPartPosted, "")
+
 	test = new(TestStruct)
 	r, _ = http.NewRequest(http.MethodPost, "/decode2/13", strings.NewReader(form.Encode()))
 	r.Header.Set(ContentType, ApplicationForm)
@@ -161,6 +176,28 @@ func TestDecode(t *testing.T) {
 	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(http.MethodPost, "/decode3/11", body)
+	r.Header.Set(ContentType, writer.FormDataContentType())
+	w = httptest.NewRecorder()
+
+	hf.ServeHTTP(w, r)
+	Equal(t, w.Code, http.StatusOK)
+	Equal(t, test.ID, 11)
+	Equal(t, test.Posted, "")
+	Equal(t, test.MultiPartPosted, "value")
+
 	jsonBody := `{"ID":13,"Posted":"value","MultiPartPosted":"value"}`
 	test = new(TestStruct)
 	r, _ = http.NewRequest(http.MethodPost, "/decode/13", strings.NewReader(jsonBody))
@@ -447,6 +484,46 @@ func TestXML(t *testing.T) {
 	Equal(t, w.Body.String(), "xml: unsupported type: func()\n")
 }
 
+func TestBadParseForm(t *testing.T) {
+
+	// successful scenarios tested under TestDecode
+
+	p := New()
+	p.Get("/users/:id", func(w http.ResponseWriter, r *http.Request) {
+
+		if err := ParseForm(r); err != nil {
+			if _, errr := w.Write([]byte(err.Error())); errr != nil {
+				panic(errr)
+			}
+			return
+		}
+	})
+
+	code, body := request(http.MethodGet, "/users/16?test=%2f%%efg", p)
+	Equal(t, code, http.StatusOK)
+	Equal(t, body, "invalid URL escape \"%%e\"")
+}
+
+func TestBadParseMultiPartForm(t *testing.T) {
+
+	// successful scenarios tested under TestDecode
+
+	p := New()
+	p.Get("/users/:id", func(w http.ResponseWriter, r *http.Request) {
+
+		if err := ParseMultipartForm(r, 10<<5); err != nil {
+			if _, errr := w.Write([]byte(err.Error())); errr != nil {
+				panic(err)
+			}
+			return
+		}
+	})
+
+	code, body := requestMultiPart(http.MethodGet, "/users/16?test=%2f%%efg", p)
+	Equal(t, code, http.StatusOK)
+	Equal(t, body, "invalid URL escape \"%%e\"")
+}
+
 type gzipWriter struct {
 	io.Writer
 	http.ResponseWriter

pure.go

@@ -491,6 +491,8 @@ END:
 
 	if len(rv.params) > 0 {
 
+		rv.formParsed = false
+
 		// create requestVars and store on context
 		r = r.WithContext(context.WithValue(r.Context(), defaultContextIdentifier, rv))
 	}

pure_test.go

@@ -1,7 +1,11 @@
 package pure
 
 import (
+	"bytes"
+	"fmt"
+	"io"
 	"io/ioutil"
+	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
 	"strconv"
@@ -864,3 +868,41 @@ func request(method, path string, p *Pure) (int, string) {
 	hf.ServeHTTP(w, r)
 	return w.Code, w.Body.String()
 }
+
+func requestMultiPart(method string, url string, p *Pure) (int, string) {
+
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+
+	part, err := writer.CreateFormFile("file", "test.txt")
+	if err != nil {
+		fmt.Println("ERR FILE:", err)
+	}
+
+	buff := bytes.NewBufferString("FILE TEST DATA")
+	_, err = io.Copy(part, buff)
+	if err != nil {
+		fmt.Println("ERR COPY:", err)
+	}
+
+	err = writer.WriteField("username", "joeybloggs")
+	if err != nil {
+		fmt.Println("ERR:", err)
+	}
+
+	err = writer.Close()
+	if err != nil {
+		fmt.Println("ERR:", err)
+	}
+
+	r, _ := http.NewRequest(method, url, body)
+	r.Header.Set(ContentType, writer.FormDataContentType())
+	wr := &closeNotifyingRecorder{
+		httptest.NewRecorder(),
+		make(chan bool, 1),
+	}
+	hf := p.Serve()
+	hf.ServeHTTP(wr, r)
+
+	return wr.Code, wr.Body.String()
+}

request_vars.go

@@ -16,6 +16,7 @@ type requestVars struct {
 	r           *http.Request
 	params      Params
 	queryParams url.Values
+	formParsed  bool
 }
 
 // Params returns the current routes Params