Adding 1.13 support; specifically, I am using errors.As for passed in errors to ensure that wrapped errors still work

Author: joncalhoun

.travis.yml

@@ -2,4 +2,4 @@ language: go
 
 go:
   - master
-  - "1.10"
+  - "1.13"

builder.go

@@ -7,6 +7,8 @@
 package form
 
 import (
+	"errors"
+	"fmt"
 	"html/template"
 	"strings"
 )
@@ -81,7 +83,7 @@ func (b *Builder) Inputs(v interface{}, errs ...error) (template.HTML, error) {
 		return "", err
 	}
 	fields := fields(v)
-	errors := errors(errs)
+	errors := fieldErrors(errs)
 	var html template.HTML
 	for _, field := range fields {
 		var sb strings.Builder
@@ -180,11 +182,12 @@ type fieldError interface {
 // Any errors that implement this interface are then used to build the
 // slice of errors for the field, meaning you can provide multiple
 // errors for the same field and all will be utilized.
-func errors(errs []error) map[string][]string {
+func fieldErrors(errs []error) map[string][]string {
 	ret := make(map[string][]string)
 	for _, err := range errs {
-		fe, ok := err.(fieldError)
-		if !ok {
+		var fe fieldError
+		if !errors.As(err, &fe) {
+			fmt.Println(err, "isnt field error")
 			continue
 		}
 		field, fieldErr := fe.FieldError()

builder_test.go

@@ -1,6 +1,8 @@
 package form
 
 import (
+	"errors"
+	"fmt"
 	"html/template"
 	"reflect"
 	"strings"
@@ -49,3 +51,82 @@ func TestBuilder_Inputs(t *testing.T) {
 		})
 	}
 }
+
+type testFieldError struct {
+	field, err string
+}
+
+func (e testFieldError) Error() string {
+	return fmt.Sprintf("invalid field: %v", e.field)
+}
+
+func (e testFieldError) FieldError() (field, err string) {
+	return e.field, e.err
+}
+
+func TestBuilder_Inputs_errors(t *testing.T) {
+	// Sanity check on our test type first
+	tfe := testFieldError{
+		field: "field",
+		err:   "err",
+	}
+	var fe fieldError
+	if !errors.As(tfe, &fe) {
+		t.Fatalf("As(testFieldError, fieldError) = false")
+	}
+	if !errors.As(fmt.Errorf("wrapped: %w", tfe), &fe) {
+		t.Fatalf("As(wrapped, fieldError) = false")
+	}
+
+	tpl := template.Must(template.New("").Funcs(FuncMap()).Parse(strings.TrimSpace(`
+		<label>{{.Label}}</label>{{range errors}}<p>{{.}}</p>{{end}}
+	`)))
+	tests := []struct {
+		name   string
+		tpl    *template.Template
+		arg    interface{}
+		errors []error
+		want   template.HTML
+	}{
+		{
+			name: "label and input",
+			tpl:  tpl,
+			arg: struct {
+				Name  string
+				Email string `form:"type=email;[email protected]"`
+			}{
+				Name: "Michael Scott",
+			},
+			errors: []error{
+				fmt.Errorf("wrapped: %w", testFieldError{
+					field: "Name",
+					err:   "is required",
+				}),
+				fmt.Errorf("first: %w", fmt.Errorf("second: %w", testFieldError{
+					field: "Email",
+					err:   "is taken",
+				})),
+			},
+			want: template.HTML(strings.Join([]string{
+				strings.TrimSpace(`
+					<label>Name</label><p>is required</p>`),
+				strings.TrimSpace(`
+            <label>Email</label><p>is taken</p>`),
+			}, "")),
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			b := &Builder{
+				InputTemplate: tc.tpl,
+			}
+			got, err := b.Inputs(tc.arg, tc.errors...)
+			if err != nil {
+				t.Errorf("Builder.Inputs() err = %v, want %v", err, nil)
+			}
+			if !reflect.DeepEqual(got, tc.want) {
+				t.Errorf("Builder.Inputs() = %v, want %v", got, tc.want)
+			}
+		})
+	}
+}