Add competitor benchmarks

- corrected a couple of benchmarks with typos.

Author: joeybloggs

README.md

@@ -152,6 +152,15 @@ decoder.RegisterCustomTypeFunc(func(vals []string) (interface{}, error) {
 	}, time.Time{})
 ```
 
+Ignoring Fields
+--------------
+you can tell form to ignore fields using `-` in the tag
+```go
+type MyStruct struct {
+    Field string `form:"-"`
+}
+```
+
 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.2 darwin/amd64
@@ -162,18 +171,19 @@ NOTE: the 1 allocation and B/op in the first 4 is actually the struct allocating
 go test -bench=. -benchmem=true
 
 PASS
-BenchmarkSimpleUserStruct-8                          	 5000000	       320 ns/op	      64 B/op	       1 allocs/op
-BenchmarkSimpleUserStructParallel-8                  	20000000	       110 ns/op	      64 B/op	       1 allocs/op
-BenchmarkPrimitivesStructAllPrimitivesTypes-8        	 1000000	      1075 ns/op	      96 B/op	       1 allocs/op
-BenchmarkPrimitivesStructAllPrimitivesTypesParallel-8	 5000000	       285 ns/op	      96 B/op	       1 allocs/op
-BenchmarkComplexArrayStructAllTypes-8                	  100000	     19748 ns/op	    6600 B/op	     143 allocs/op
-BenchmarkComplexArrayStructAllTypesParallel-8        	  300000	      5844 ns/op	    6600 B/op	     143 allocs/op
-BenchmarkComplexMapStructAllTypes-8                  	   50000	     33943 ns/op	   20276 B/op	     224 allocs/op
-BenchmarkComplexMapStructAllTypesParallel-8          	  200000	     12228 ns/op	   20277 B/op	     224 allocs/op
-BenchmarkArrayMapNestedStruct-8                      	  300000	      4658 ns/op	    1840 B/op	      27 allocs/op
-BenchmarkArrayMapNestedStructParallel-8              	 1000000	      1498 ns/op	    1840 B/op	      27 allocs/op
+BenchmarkSimpleUserStruct-8                                 	 5000000	       299 ns/op	      64 B/op	       1 allocs/op
+BenchmarkSimpleUserStructParallel-8                         	20000000	       110 ns/op	      64 B/op	       1 allocs/op
+BenchmarkPrimitivesStructAllPrimitivesTypes-8               	 2000000	       956 ns/op	      96 B/op	       1 allocs/op
+BenchmarkPrimitivesStructAllPrimitivesTypesParallel-8       	 5000000	       285 ns/op	      96 B/op	       1 allocs/op
+BenchmarkComplexArrayStructAllTypes-8                       	  100000	     20706 ns/op	    6776 B/op	     159 allocs/op
+BenchmarkComplexArrayStructAllTypesParallel-8               	  200000	      6158 ns/op	    6776 B/op	     159 allocs/op
+BenchmarkComplexMapStructAllTypes-8                         	   50000	     35548 ns/op	   20966 B/op	     245 allocs/op
+BenchmarkComplexMapStructAllTypesParallel-8                 	  200000	     11984 ns/op	   20966 B/op	     245 allocs/op
+BenchmarkArrayMapNestedStruct-8                             	  200000	      5617 ns/op	    2064 B/op	      37 allocs/op
+BenchmarkArrayMapNestedStructParallel-8                     	 1000000	      2032 ns/op	    2064 B/op	      37 allocs/op
 ```
 
+Competitor benchmarks can be found [here](https://github.com/go-playground/form/blob/master/benchmarks/benchmarks.md)
 
 Complimentary Software
 ----------------------

benchmarks/benchmarks.md

@@ -0,0 +1,45 @@
+## Benchmarks
+
+### go-playground/form
+BenchmarkSimpleUserStruct-8                                 	 5000000	       299 ns/op	      64 B/op	       1 allocs/op
+BenchmarkSimpleUserStructParallel-8                         	20000000	       110 ns/op	      64 B/op	       1 allocs/op
+BenchmarkPrimitivesStructAllPrimitivesTypes-8               	 2000000	       956 ns/op	      96 B/op	       1 allocs/op
+BenchmarkPrimitivesStructAllPrimitivesTypesParallel-8       	 5000000	       285 ns/op	      96 B/op	       1 allocs/op
+BenchmarkComplexArrayStructAllTypes-8                       	  100000	     20706 ns/op	    6776 B/op	     159 allocs/op
+BenchmarkComplexArrayStructAllTypesParallel-8               	  200000	      6158 ns/op	    6776 B/op	     159 allocs/op
+BenchmarkComplexMapStructAllTypes-8                         	   50000	     35548 ns/op	   20966 B/op	     245 allocs/op
+BenchmarkComplexMapStructAllTypesParallel-8                 	  200000	     11984 ns/op	   20966 B/op	     245 allocs/op
+BenchmarkArrayMapNestedStruct-8                             	  200000	      5617 ns/op	    2064 B/op	      37 allocs/op
+BenchmarkArrayMapNestedStructParallel-8                     	 1000000	      2032 ns/op	    2064 B/op	      37 allocs/op
+
+### gorilla/schema
+BenchmarkSimpleUserStructGorilla-8                          	  500000	      3063 ns/op	     520 B/op	      23 allocs/op
+BenchmarkSimpleUserStructGorillaParallel-8                  	 1000000	      1026 ns/op	     520 B/op	      23 allocs/op
+BenchmarkPrimitivesStructAllPrimitivesTypesGorilla-8        	  200000	     11136 ns/op	    1536 B/op	      84 allocs/op
+BenchmarkPrimitivesStructAllPrimitivesTypesGorillaParallel-8	  500000	      3928 ns/op	    1536 B/op	      84 allocs/op
+BenchmarkComplexArrayStructAllTypesGorilla-8                	   50000	     34162 ns/op	    5416 B/op	     223 allocs/op
+BenchmarkComplexArrayStructAllTypesGorillaParallel-8        	  200000	     11937 ns/op	    5416 B/op	     223 allocs/op
+BenchmarkComplexMapStructAllTypesGorilla-8                  	       0	         0 ns/op	       0 B/op	       0 allocs/op
+--- BENCH: BenchmarkComplexMapStructAllTypesGorilla-8
+	gorilla_scheme_test.go:116: Gorilla does not support map parsing at this time
+BenchmarkComplexMapStructAllTypesGorillaParallel-8          	       0	         0 ns/op	       0 B/op	       0 allocs/op
+--- BENCH: BenchmarkComplexMapStructAllTypesGorillaParallel-8
+	gorilla_scheme_test.go:121: Gorilla does not support map parsing at this time
+BenchmarkArrayMapNestedStructGorilla-8                      	  200000	     10393 ns/op	    2269 B/op	      73 allocs/op
+BenchmarkArrayMapNestedStructGorillaParallel-8              	  500000	      3484 ns/op	    2269 B/op	      73 allocs/op
+
+### monoculum/formam
+BenchmarkSimpleUserStructFormam-8                           	  500000	      3713 ns/op	     264 B/op	      19 allocs/op
+BenchmarkSimpleUserStructFormamParallel-8                   	 1000000	      1017 ns/op	     264 B/op	      19 allocs/op
+BenchmarkPrimitivesStructAllPrimitivesFormamTypes-8         	  100000	     12197 ns/op	    1280 B/op	     134 allocs/op
+BenchmarkPrimitivesStructAllPrimitivesTypesFormamParallel-8 	  500000	      3905 ns/op	    1280 B/op	     134 allocs/op
+BenchmarkComplexArrayStructAllTypesFormam-8                 	   30000	     58650 ns/op	    6371 B/op	     522 allocs/op
+BenchmarkComplexArrayStructAllTypesFormamParallel-8         	  100000	     19046 ns/op	    6349 B/op	     521 allocs/op
+BenchmarkComplexMapStructAllTypesFormam-8                   	--- FAIL: BenchmarkComplexMapStructAllTypesFormam-8
+	formam_test.go:142: formam: the key with uint16 type (map[uint16]uint16) in the path Uint16.0 should implements the TextUnmarshaler interface for to can decode it
+BenchmarkComplexMapStructAllTypesFormamParallel-8           	--- FAIL: BenchmarkComplexMapStructAllTypesFormamParallel-8
+	formam_test.go:158: formam: the key with int type (map[int]int) in the path Int.0 should implements the TextUnmarshaler interface for to can decode it
+BenchmarkArrayMapNestedStructFormam-8                       	--- FAIL: BenchmarkArrayMapNestedStructFormam-8
+	formam_test.go:174: formam: not supported type for field "Value" in path "NestedPtrArray[1].Value"
+BenchmarkArrayMapNestedStructFormamParallel-8               	--- FAIL: BenchmarkArrayMapNestedStructFormamParallel-8
+	formam_test.go:189: formam: not supported type for field "Value" in path "NestedPtrArray[0].Value"

benchmarks/benchmarks_test.go

@@ -10,10 +10,10 @@ import (
 // Simple Benchmarks
 
 type User struct {
-	FirstName string `form:"fname"`
-	LastName  string `form:"lname"`
-	Email     string `form:"email"`
-	Age       uint8  `form:"age"`
+	FirstName string `form:"fname" schema:"fname" formam:"fname"`
+	LastName  string `form:"lname" schema:"lname" formam:"lname"`
+	Email     string `form:"email" schema:"email" formam:"email"`
+	Age       uint8  `form:"age"   schema:"age"   formam:"age"`
 }
 
 func getUserStructValues() url.Values {
@@ -90,7 +90,7 @@ func getPrimitivesStructValues() url.Values {
 		"Uint64":  []string{"5"},
 		"Float32": []string{"1.1"},
 		"Float64": []string{"5.0"},
-		"Bool":    []string{"t"},
+		"Bool":    []string{"true"},
 	}
 }
 
@@ -144,9 +144,9 @@ type ComplexArrayStruct struct {
 	Uint8        []uint8
 	Uint8Ptr     []*uint8
 	Uint16       []uint16
-	UInt16Ptr    []*uint16
-	UInt32       []uint32
-	Uint31Ptr    []*uint32
+	Uint16Ptr    []*uint16
+	Uint32       []uint32
+	Uint32Ptr    []*uint32
 	Uint64       []uint64
 	Uint64Ptr    []*uint64
 	NestedInt    [][]int
@@ -236,9 +236,9 @@ type ComplexMapStruct struct {
 	Uint8        map[uint8]uint8
 	Uint8Ptr     map[*uint8]*uint8
 	Uint16       map[uint16]uint16
-	UInt16Ptr    map[*uint16]*uint16
-	UInt32       map[*uint32]*uint32
-	Uint31Ptr    map[*uint32]*uint32
+	Uint16Ptr    map[*uint16]*uint16
+	Uint32       map[*uint32]*uint32
+	Uint32Ptr    map[*uint32]*uint32
 	Uint64       map[*uint64]*uint64
 	Uint64Ptr    map[*uint64]*uint64
 	NestedInt    map[int]map[int]int
@@ -330,8 +330,8 @@ func getNestedStructValues() url.Values {
 		"NestedArray[0].Value": []string{"value"},
 		"NestedArray[1].Value": []string{"value"},
 		// Nested Array Ptr
-		"NestedArrayPtr[0].Value": []string{"value"},
-		"NestedArrayPtr[1].Value": []string{"value"},
+		"NestedPtrArray[0].Value": []string{"value"},
+		"NestedPtrArray[1].Value": []string{"value"},
 		// Nested 2
 		"Nested2.Value":         []string{"value"},
 		"Nested2.Nested2.Value": []string{"value"},

benchmarks/formam_test.go

@@ -0,0 +1,193 @@
+package benchmarks
+
+import (
+	"net/url"
+	"testing"
+
+	"github.com/monoculum/formam"
+)
+
+// Simple Benchmarks
+
+func BenchmarkSimpleUserStructFormam(b *testing.B) {
+
+	values := getUserStructValues()
+	var err error
+	b.ReportAllocs()
+	for n := 0; n < b.N; n++ {
+		var test User
+		if err = formam.Decode(values, &test); err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkSimpleUserStructFormamParallel(b *testing.B) {
+
+	values := getUserStructValues()
+	var err error
+
+	b.ReportAllocs()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			var test User
+			if err = formam.Decode(values, &test); err != nil {
+				b.Error(err)
+			}
+		}
+	})
+}
+
+// Primitives ALL types
+
+func BenchmarkPrimitivesStructAllPrimitivesFormamTypes(b *testing.B) {
+	values := getPrimitivesStructValues()
+	var err error
+
+	b.ReportAllocs()
+	for n := 0; n < b.N; n++ {
+		var test PrimitivesStruct
+		if err = formam.Decode(values, &test); err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkPrimitivesStructAllPrimitivesTypesFormamParallel(b *testing.B) {
+	values := getPrimitivesStructValues()
+	var err error
+
+	b.ReportAllocs()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			var test PrimitivesStruct
+			if err = formam.Decode(values, &test); err != nil {
+				b.Error(err)
+			}
+		}
+	})
+}
+
+// Complex Array ALL types
+
+func BenchmarkComplexArrayStructAllTypesFormam(b *testing.B) {
+	values := getComplexArrayStructValues()
+	var err error
+
+	b.ReportAllocs()
+	for n := 0; n < b.N; n++ {
+		var test ComplexArrayStruct
+		if err = formam.Decode(values, &test); err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkComplexArrayStructAllTypesFormamParallel(b *testing.B) {
+	values := getComplexArrayStructValues()
+	var err error
+
+	b.ReportAllocs()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			var test ComplexArrayStruct
+			if err = formam.Decode(values, &test); err != nil {
+				b.Error(err)
+			}
+		}
+	})
+}
+
+// Complex Map ALL types
+
+func getComplexMapStructValuesFormam() url.Values {
+	return url.Values{
+		"String.key":       []string{"value"},
+		"StringPtr.key":    []string{"value"},
+		"Int.0":            []string{"1"},
+		"IntPtr.0":         []string{"1"},
+		"Int8.0":           []string{"1"},
+		"Int8Ptr.0":        []string{"1"},
+		"Int16.0":          []string{"1"},
+		"Int16Ptr.0":       []string{"1"},
+		"Int32.0":          []string{"1"},
+		"Int32Ptr.0":       []string{"1"},
+		"Int64.0":          []string{"1"},
+		"Int64Ptr.0":       []string{"1"},
+		"Uint.0":           []string{"1"},
+		"UintPtr.0":        []string{"1"},
+		"Uint8.0":          []string{"1"},
+		"Uint8Ptr.0":       []string{"1"},
+		"Uint16.0":         []string{"1"},
+		"Uint16Ptr.0":      []string{"1"},
+		"Uint32.0":         []string{"1"},
+		"Uint32Ptr.0":      []string{"1"},
+		"Uint64.0":         []string{"1"},
+		"Uint64Ptr.0":      []string{"1"},
+		"NestedInt.1.2":    []string{"3"},
+		"NestedIntPtr.1.2": []string{"3"},
+	}
+}
+
+func BenchmarkComplexMapStructAllTypesFormam(b *testing.B) {
+	// b.Log("Formam only supports map key of string at this time")
+	// b.SkipNow()
+	values := getComplexMapStructValuesFormam()
+	var err error
+
+	b.ReportAllocs()
+	for n := 0; n < b.N; n++ {
+		var test ComplexMapStruct
+		if err = formam.Decode(values, &test); err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkComplexMapStructAllTypesFormamParallel(b *testing.B) {
+	// b.Log("Formam only supports map key of string at this time")
+	// b.SkipNow()
+	values := getComplexMapStructValuesFormam()
+	var err error
+
+	b.ReportAllocs()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			var test ComplexMapStruct
+			if err = formam.Decode(values, &test); err != nil {
+				b.Error(err)
+			}
+		}
+	})
+}
+
+// NestedStruct Benchmarks
+
+func BenchmarkArrayMapNestedStructFormam(b *testing.B) {
+
+	values := getNestedStructValues()
+	var err error
+	b.ReportAllocs()
+	for n := 0; n < b.N; n++ {
+		var test NestedStruct
+		if err = formam.Decode(values, &test); err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkArrayMapNestedStructFormamParallel(b *testing.B) {
+
+	values := getNestedStructValues()
+	var err error
+
+	b.ReportAllocs()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			var test NestedStruct
+			if err = formam.Decode(values, &test); err != nil {
+				b.Error(err)
+			}
+		}
+	})
+}