Merge pull request #352 from o1egl/bind_form

Add form binding.

binder.go

@@ -0,0 +1,207 @@
+package echo
+
+import (
+	"encoding/json"
+	"encoding/xml"
+	"errors"
+	"net/http"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+type (
+	// Binder is the interface that wraps the Bind method.
+	Binder interface {
+		Bind(*http.Request, interface{}) error
+	}
+
+	binder struct {
+		maxMemory int64
+	}
+)
+
+const (
+	defaultMaxMemory = 32 << 20 // 32 MB
+)
+
+// SetMaxBodySize sets multipart forms max body size
+func (b *binder) SetMaxMemory(size int64) {
+	b.maxMemory = size
+}
+
+// MaxBodySize return multipart forms max body size
+func (b *binder) MaxMemory() int64 {
+	return b.maxMemory
+}
+
+func (b *binder) Bind(r *http.Request, i interface{}) (err error) {
+	ct := r.Header.Get(ContentType)
+	err = ErrUnsupportedMediaType
+	switch {
+	case strings.HasPrefix(ct, ApplicationJSON):
+		if err = json.NewDecoder(r.Body).Decode(i); err != nil {
+			err = NewHTTPError(http.StatusBadRequest, err.Error())
+		}
+	case strings.HasPrefix(ct, ApplicationXML):
+		if err = xml.NewDecoder(r.Body).Decode(i); err != nil {
+			err = NewHTTPError(http.StatusBadRequest, err.Error())
+		}
+	case strings.HasPrefix(ct, ApplicationForm):
+		if err = b.bindForm(r, i); err != nil {
+			err = NewHTTPError(http.StatusBadRequest, err.Error())
+		}
+	case strings.HasPrefix(ct, MultipartForm):
+		if err = b.bindMultiPartForm(r, i); err != nil {
+			err = NewHTTPError(http.StatusBadRequest, err.Error())
+		}
+	}
+	return
+}
+
+func (binder) bindForm(r *http.Request, i interface{}) error {
+	if err := r.ParseForm(); err != nil {
+		return err
+	}
+	return mapForm(i, r.Form)
+}
+
+func (b binder) bindMultiPartForm(r *http.Request, i interface{}) error {
+	if b.maxMemory == 0 {
+		b.maxMemory = defaultMaxMemory
+	}
+	if err := r.ParseMultipartForm(b.maxMemory); err != nil {
+		return err
+	}
+	return mapForm(i, r.Form)
+}
+
+func mapForm(ptr interface{}, form map[string][]string) error {
+	typ := reflect.TypeOf(ptr).Elem()
+	val := reflect.ValueOf(ptr).Elem()
+	for i := 0; i < typ.NumField(); i++ {
+		typeField := typ.Field(i)
+		structField := val.Field(i)
+		if !structField.CanSet() {
+			continue
+		}
+
+		structFieldKind := structField.Kind()
+		inputFieldName := typeField.Tag.Get("form")
+		if inputFieldName == "" {
+			inputFieldName = typeField.Name
+
+			// if "form" tag is nil, we inspect if the field is a struct.
+			// this would not make sense for JSON parsing but it does for a form
+			// since data is flatten
+			if structFieldKind == reflect.Struct {
+				err := mapForm(structField.Addr().Interface(), form)
+				if err != nil {
+					return err
+				}
+				continue
+			}
+		}
+		inputValue, exists := form[inputFieldName]
+		if !exists {
+			continue
+		}
+
+		numElems := len(inputValue)
+		if structFieldKind == reflect.Slice && numElems > 0 {
+			sliceOf := structField.Type().Elem().Kind()
+			slice := reflect.MakeSlice(structField.Type(), numElems, numElems)
+			for i := 0; i < numElems; i++ {
+				if err := setWithProperType(sliceOf, inputValue[i], slice.Index(i)); err != nil {
+					return err
+				}
+			}
+			val.Field(i).Set(slice)
+		} else {
+			if err := setWithProperType(typeField.Type.Kind(), inputValue[0], structField); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func setWithProperType(valueKind reflect.Kind, val string, structField reflect.Value) error {
+	switch valueKind {
+	case reflect.Int:
+		return setIntField(val, 0, structField)
+	case reflect.Int8:
+		return setIntField(val, 8, structField)
+	case reflect.Int16:
+		return setIntField(val, 16, structField)
+	case reflect.Int32:
+		return setIntField(val, 32, structField)
+	case reflect.Int64:
+		return setIntField(val, 64, structField)
+	case reflect.Uint:
+		return setUintField(val, 0, structField)
+	case reflect.Uint8:
+		return setUintField(val, 8, structField)
+	case reflect.Uint16:
+		return setUintField(val, 16, structField)
+	case reflect.Uint32:
+		return setUintField(val, 32, structField)
+	case reflect.Uint64:
+		return setUintField(val, 64, structField)
+	case reflect.Bool:
+		return setBoolField(val, structField)
+	case reflect.Float32:
+		return setFloatField(val, 32, structField)
+	case reflect.Float64:
+		return setFloatField(val, 64, structField)
+	case reflect.String:
+		structField.SetString(val)
+	default:
+		return errors.New("Unknown type")
+	}
+	return nil
+}
+
+func setIntField(val string, bitSize int, field reflect.Value) error {
+	if val == "" {
+		val = "0"
+	}
+	intVal, err := strconv.ParseInt(val, 10, bitSize)
+	if err == nil {
+		field.SetInt(intVal)
+	}
+	return err
+}
+
+func setUintField(val string, bitSize int, field reflect.Value) error {
+	if val == "" {
+		val = "0"
+	}
+	uintVal, err := strconv.ParseUint(val, 10, bitSize)
+	if err == nil {
+		field.SetUint(uintVal)
+	}
+	return err
+}
+
+func setBoolField(val string, field reflect.Value) error {
+	if val == "" {
+		val = "false"
+	}
+	boolVal, err := strconv.ParseBool(val)
+	if err == nil {
+		field.SetBool(boolVal)
+	}
+	return err
+}
+
+func setFloatField(val string, bitSize int, field reflect.Value) error {
+	if val == "" {
+		val = "0.0"
+	}
+	floatVal, err := strconv.ParseFloat(val, bitSize)
+	if err == nil {
+		field.SetFloat(floatVal)
+	}
+	return err
+}

binder_test.go

@@ -0,0 +1,257 @@
+package echo
+
+import (
+	"bytes"
+	"github.com/stretchr/testify/assert"
+	"mime/multipart"
+	"net/http"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type (
+	customer struct {
+		ID   int    `json:"id" xml:"id" form:"id"`
+		Name string `json:"name" xml:"name" form:"name"`
+	}
+
+	testStruct struct {
+		I           int
+		I8          int8
+		I16         int16
+		I32         int32
+		I64         int64
+		UI          uint
+		UI8         uint8
+		UI16        uint16
+		UI32        uint32
+		UI64        uint64
+		B           bool
+		F32         float32
+		F64         float64
+		S           string
+		cantSet     string
+		DoesntExist string
+	}
+)
+
+func (t testStruct) GetCantSet() string {
+	return t.cantSet
+}
+
+var values = map[string][]string{
+	"I":       {"0"},
+	"I8":      {"8"},
+	"I16":     {"16"},
+	"I32":     {"32"},
+	"I64":     {"64"},
+	"UI":      {"0"},
+	"UI8":     {"8"},
+	"UI16":    {"16"},
+	"UI32":    {"32"},
+	"UI64":    {"64"},
+	"B":       {"true"},
+	"F32":     {"32.5"},
+	"F64":     {"64.5"},
+	"S":       {"test"},
+	"cantSet": {"test"},
+}
+
+const (
+	customerJSON     = `{"id":1,"name":"Joe"}`
+	customerXML      = `<customer><id>1</id><name>Joe</name></customer>`
+	customerForm     = `id=1&name=Joe`
+	incorrectContent = "this is incorrect content"
+)
+
+func TestMaxMemory(t *testing.T) {
+	b := new(binder)
+	b.SetMaxMemory(20)
+	assert.Equal(t, int64(20), b.MaxMemory())
+}
+
+func TestJSONBinding(t *testing.T) {
+	r, _ := http.NewRequest(POST, "/", strings.NewReader(customerJSON))
+	testBindOk(t, r, ApplicationJSON)
+	r, _ = http.NewRequest(POST, "/", strings.NewReader(incorrectContent))
+	testBindError(t, r, ApplicationJSON)
+}
+
+func TestXMLBinding(t *testing.T) {
+	r, _ := http.NewRequest(POST, "/", strings.NewReader(customerXML))
+	testBindOk(t, r, ApplicationXML)
+	r, _ = http.NewRequest(POST, "/", strings.NewReader(incorrectContent))
+	testBindError(t, r, ApplicationXML)
+}
+
+func TestFormBinding(t *testing.T) {
+	r, _ := http.NewRequest(POST, "/", strings.NewReader(customerForm))
+	testBindOk(t, r, ApplicationForm)
+	r, _ = http.NewRequest(POST, "/", nil)
+	testBindError(t, r, ApplicationForm)
+}
+
+func TestMultipartFormBinding(t *testing.T) {
+	body := new(bytes.Buffer)
+	mw := multipart.NewWriter(body)
+	mw.WriteField("id", "1")
+	mw.WriteField("name", "Joe")
+	mw.Close()
+	r, _ := http.NewRequest(POST, "/", body)
+	testBindOk(t, r, mw.FormDataContentType())
+	r, _ = http.NewRequest(POST, "/", strings.NewReader(incorrectContent))
+	testBindError(t, r, mw.FormDataContentType())
+}
+
+func TestUnsupportedMediaTypeBinding(t *testing.T) {
+	r, _ := http.NewRequest(POST, "/", strings.NewReader(customerJSON))
+	testBindError(t, r, "")
+}
+
+func TestBindFormFunc(t *testing.T) {
+	r, _ := http.NewRequest(POST, "/", strings.NewReader(customerForm))
+	r.Header.Set(ContentType, ApplicationForm)
+	b := new(binder)
+	c := new(customer)
+	if assert.NoError(t, b.bindForm(r, c)) {
+		assertCustomer(t, c)
+	}
+}
+
+func TestBindMultiPartFormFunc(t *testing.T) {
+	body := new(bytes.Buffer)
+	mw := multipart.NewWriter(body)
+	mw.WriteField("id", "1")
+	mw.WriteField("name", "Joe")
+	mw.Close()
+	r, _ := http.NewRequest(POST, "/", body)
+	r.Header.Set(ContentType, mw.FormDataContentType())
+	b := new(binder)
+	c := new(customer)
+	if assert.NoError(t, b.bindMultiPartForm(r, c)) {
+		assertCustomer(t, c)
+	}
+}
+
+func assertCustomer(t *testing.T, c *customer) {
+	assert.Equal(t, 1, c.ID)
+	assert.Equal(t, "Joe", c.Name)
+}
+
+func TestMapForm(t *testing.T) {
+	ts := new(testStruct)
+	mapForm(ts, values)
+	assertTestStruct(t, ts)
+}
+
+func TestSetWithProperType(t *testing.T) {
+	ts := new(testStruct)
+	typ := reflect.TypeOf(ts).Elem()
+	val := reflect.ValueOf(ts).Elem()
+	for i := 0; i < typ.NumField(); i++ {
+		typeField := typ.Field(i)
+		structField := val.Field(i)
+		if !structField.CanSet() {
+			continue
+		}
+		if len(values[typeField.Name]) == 0 {
+			continue
+		}
+		val := values[typeField.Name][0]
+		err := setWithProperType(typeField.Type.Kind(), val, structField)
+		assert.NoError(t, err)
+	}
+	assertTestStruct(t, ts)
+
+	type foo struct {
+		Bar bytes.Buffer
+	}
+	v := &foo{}
+	typ = reflect.TypeOf(v).Elem()
+	val = reflect.ValueOf(v).Elem()
+	assert.Error(t, setWithProperType(typ.Field(0).Type.Kind(), "5", val.Field(0)))
+}
+
+func TestSetFields(t *testing.T) {
+	ts := new(testStruct)
+	val := reflect.ValueOf(ts).Elem()
+	// Int
+	if assert.NoError(t, setIntField("5", 0, val.FieldByName("I"))) {
+		assert.Equal(t, 5, ts.I)
+	}
+	if assert.NoError(t, setIntField("", 0, val.FieldByName("I"))) {
+		assert.Equal(t, 0, ts.I)
+	}
+
+	// Uint
+	if assert.NoError(t, setUintField("10", 0, val.FieldByName("UI"))) {
+		assert.Equal(t, uint(10), ts.UI)
+	}
+	if assert.NoError(t, setUintField("", 0, val.FieldByName("UI"))) {
+		assert.Equal(t, uint(0), ts.UI)
+	}
+
+	// Float
+	if assert.NoError(t, setFloatField("15.5", 0, val.FieldByName("F32"))) {
+		assert.Equal(t, float32(15.5), ts.F32)
+	}
+	if assert.NoError(t, setFloatField("", 0, val.FieldByName("F32"))) {
+		assert.Equal(t, float32(0.0), ts.F32)
+	}
+
+	// Bool
+	if assert.NoError(t, setBoolField("true", val.FieldByName("B"))) {
+		assert.Equal(t, true, ts.B)
+	}
+	if assert.NoError(t, setBoolField("", val.FieldByName("B"))) {
+		assert.Equal(t, false, ts.B)
+	}
+}
+
+func assertTestStruct(t *testing.T, ts *testStruct) {
+	assert.Equal(t, 0, ts.I)
+	assert.Equal(t, int8(8), ts.I8)
+	assert.Equal(t, int16(16), ts.I16)
+	assert.Equal(t, int32(32), ts.I32)
+	assert.Equal(t, int64(64), ts.I64)
+	assert.Equal(t, uint(0), ts.UI)
+	assert.Equal(t, uint8(8), ts.UI8)
+	assert.Equal(t, uint16(16), ts.UI16)
+	assert.Equal(t, uint32(32), ts.UI32)
+	assert.Equal(t, uint64(64), ts.UI64)
+	assert.Equal(t, true, ts.B)
+	assert.Equal(t, float32(32.5), ts.F32)
+	assert.Equal(t, float64(64.5), ts.F64)
+	assert.Equal(t, "test", ts.S)
+	assert.Equal(t, "", ts.GetCantSet())
+}
+
+func testBindOk(t *testing.T, r *http.Request, ct string) {
+	r.Header.Set(ContentType, ct)
+	c := new(customer)
+	err := new(binder).Bind(r, c)
+	if assert.NoError(t, err) {
+		assert.Equal(t, 1, c.ID)
+		assert.Equal(t, "Joe", c.Name)
+	}
+}
+
+func testBindError(t *testing.T, r *http.Request, ct string) {
+	r.Header.Set(ContentType, ct)
+	u := new(customer)
+	err := new(binder).Bind(r, u)
+
+	switch {
+	case strings.HasPrefix(ct, ApplicationJSON), strings.HasPrefix(ct, ApplicationXML),
+		strings.HasPrefix(ct, ApplicationForm), strings.HasPrefix(ct, MultipartForm):
+		if assert.IsType(t, new(HTTPError), err) {
+			assert.Equal(t, http.StatusBadRequest, err.(*HTTPError).code)
+		}
+	default:
+		if assert.IsType(t, new(HTTPError), err) {
+			assert.Equal(t, ErrUnsupportedMediaType, err)
+		}
+
+	}
+}

context_test.go

@@ -34,7 +34,6 @@ func TestContext(t *testing.T) {
 	userJSONIndent := "{\n_?\"id\": \"1\",\n_?\"name\": \"Joe\"\n_}"
 	userXML := `<user><id>1</id><name>Joe</name></user>`
 	userXMLIndent := "_<user>\n_?<id>1</id>\n_?<name>Joe</name>\n_</user>"
-	incorrectContent := "this is incorrect content"
 
 	var nonMarshallableChannel chan bool
 
@@ -64,23 +63,15 @@ func TestContext(t *testing.T) {
 	c.Set("user", "Joe")
 	assert.Equal(t, "Joe", c.Get("user"))
 
-	//------
 	// Bind
-	//------
-
-	// JSON
-	testBindOk(t, c, ApplicationJSON)
-	c.request, _ = http.NewRequest(POST, "/", strings.NewReader(incorrectContent))
-	testBindError(t, c, ApplicationJSON)
-
-	// XML
-	c.request, _ = http.NewRequest(POST, "/", strings.NewReader(userXML))
-	testBindOk(t, c, ApplicationXML)
-	c.request, _ = http.NewRequest(POST, "/", strings.NewReader(incorrectContent))
-	testBindError(t, c, ApplicationXML)
-
-	// Unsupported
-	testBindError(t, c, "")
+	c.request, _ = http.NewRequest(POST, "/", strings.NewReader(userJSON))
+	c.request.Header.Set(ContentType, ApplicationJSON)
+	u := new(user)
+	err := c.Bind(u)
+	if assert.NoError(t, err) {
+		assert.Equal(t, "1", u.ID)
+		assert.Equal(t, "Joe", u.Name)
+	}
 
 	//--------
 	// Render
@@ -90,7 +81,7 @@ func TestContext(t *testing.T) {
 		templates: template.Must(template.New("hello").Parse("Hello, {{.}}!")),
 	}
 	c.echo.SetRenderer(tpl)
-	err := c.Render(http.StatusOK, "hello", "Joe")
+	err = c.Render(http.StatusOK, "hello", "Joe")
 	if assert.NoError(t, err) {
 		assert.Equal(t, http.StatusOK, rec.Code)
 		assert.Equal(t, "Hello, Joe!", rec.Body.String())
@@ -295,31 +286,3 @@ func TestContextEcho(t *testing.T) {
 	// Should be null when initialized without one
 	assert.Nil(t, c.Echo())
 }
-
-func testBindOk(t *testing.T, c *Context, ct string) {
-	c.request.Header.Set(ContentType, ct)
-	u := new(user)
-	err := c.Bind(u)
-	if assert.NoError(t, err) {
-		assert.Equal(t, "1", u.ID)
-		assert.Equal(t, "Joe", u.Name)
-	}
-}
-
-func testBindError(t *testing.T, c *Context, ct string) {
-	c.request.Header.Set(ContentType, ct)
-	u := new(user)
-	err := c.Bind(u)
-
-	switch ct {
-	case ApplicationJSON, ApplicationXML:
-		if assert.IsType(t, new(HTTPError), err) {
-			assert.Equal(t, http.StatusBadRequest, err.(*HTTPError).code)
-		}
-	default:
-		if assert.IsType(t, new(HTTPError), err) {
-			assert.Equal(t, ErrUnsupportedMediaType, err)
-		}
-
-	}
-}

echo.go

@@ -33,8 +33,6 @@ package echo
 
 import (
 	"bytes"
-	"encoding/json"
-	"encoding/xml"
 	"errors"
 	"fmt"
 	"io"
@@ -43,7 +41,6 @@ import (
 	"path/filepath"
 	"reflect"
 	"runtime"
-	"strings"
 	"sync"
 
 	"github.com/labstack/gommon/log"
@@ -116,14 +113,6 @@ type (
 	// HTTPErrorHandler is a centralized HTTP error handler.
 	HTTPErrorHandler func(error, *Context)
 
-	// Binder is the interface that wraps the Bind method.
-	Binder interface {
-		Bind(*http.Request, interface{}) error
-	}
-
-	binder struct {
-	}
-
 	// Validator is the interface that wraps the Validate method.
 	Validator interface {
 		Validate() error
@@ -736,19 +725,3 @@ func wrapHandler(h Handler) HandlerFunc {
 		panic("unknown handler")
 	}
 }
-
-func (binder) Bind(r *http.Request, i interface{}) (err error) {
-	ct := r.Header.Get(ContentType)
-	err = ErrUnsupportedMediaType
-	if strings.HasPrefix(ct, ApplicationJSON) {
-		if err = json.NewDecoder(r.Body).Decode(i); err != nil {
-			err = NewHTTPError(http.StatusBadRequest, err.Error())
-		}
-	} else if strings.HasPrefix(ct, ApplicationXML) {
-		if err = xml.NewDecoder(r.Body).Decode(i); err != nil {
-			err = NewHTTPError(http.StatusBadRequest, err.Error())
-		}
-
-	}
-	return
-}

echo_test.go

@@ -12,6 +12,7 @@ import (
 
 	"errors"
 
+	"github.com/labstack/gommon/log"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/net/websocket"
 )
@@ -39,6 +40,29 @@ func TestEcho(t *testing.T) {
 	// DefaultHTTPErrorHandler
 	e.DefaultHTTPErrorHandler(errors.New("error"), c)
 	assert.Equal(t, http.StatusInternalServerError, rec.Code)
+
+	// Logger
+	l := log.New("test")
+	e.SetLogger(l)
+	assert.Equal(t, l, e.Logger())
+
+	// Autoindex
+	e.AutoIndex(true)
+	assert.True(t, e.autoIndex)
+}
+
+func TestListDir(t *testing.T) {
+	e := New()
+	req, _ := http.NewRequest(GET, "/", nil)
+	rec := httptest.NewRecorder()
+	c := NewContext(req, NewResponse(rec, e), e)
+	fs := http.Dir("_fixture")
+	f, err := fs.Open("images")
+	assert.NoError(t, err)
+	if assert.NoError(t, listDir(f, c)) {
+		assert.Equal(t, TextHTMLCharsetUTF8, rec.Header().Get(ContentType))
+		assert.Equal(t, "<pre>\n<a href=\"walle.png\" style=\"color: #212121;\">walle.png</a>\n</pre>\n", rec.Body.String())
+	}
 }
 
 func TestEchoIndex(t *testing.T) {
@@ -399,6 +423,8 @@ func TestEchoHTTPError(t *testing.T) {
 	he := NewHTTPError(http.StatusBadRequest, m)
 	assert.Equal(t, http.StatusBadRequest, he.Code())
 	assert.Equal(t, m, he.Error())
+	he.SetCode(http.StatusOK)
+	assert.Equal(t, http.StatusOK, he.Code())
 }
 
 func TestEchoServer(t *testing.T) {