In the README there's a section about ignoring fields by tagging them with form:"-". Would it be possible to add an option to the decoder (like SetTagName(tagName string)) to ignore all struct fields not explicitly tagged with form:"fieldName" (or the custom tag name if set)?

The problem I see is the unintended injection of data because this library is used with user-generated content and accepts form data. Having a language like Go that is strictly typed goes a long way but I do have to go through all of my models and tag them with form:"-". Still, I know this is my fault and want to thank you for this awesome library!

The reason I'm asking is that I'm also using these structs that are filled with form data to also transform the data for later usage. Sometimes there's additional fields I add that need to be public to use within the app but are not supposed to be accepted via the form data. I'm also always tagging all fields I accept even if the form field's name is the lowercased version of the struct field name (so technically, I wouldn't have to add the struct tag) but you immediately see what's accepted via a form and what's not when looking at the struct definition.

If this is a request you'd rather not implement then a few pointers on how to make this safer for me or where you'd start looking in the code. :)

Add a new setting that allows using square brackets as a namespace separator.

In a company I work for we use square brackets as a struct separator.

• [*] Tests exist or have been written that cover this particular change.

@go-playground/admins

type T struct { X *uint8 form:"x,omitempty" }

func main() { tx := uint8(0) x := T{&tx} encoder := form.NewEncoder() values, _ := encoder.Encode(x) fmt.Println(values) // blank map }

If I try to set value to 0, encoder ignores this field

If you have a query of b[0].Foo=1&b[0].Bar=2 and b is a custom struct then my CustomTypeFunc won't be called. However, if the query is b[0]=Foo%3D1%26Bar%3D2 then it works as expected, but I can't expect the caller to know which structs are custom and which aren't.

Test/example case:

package main

import (
	"net/url"
	"github.com/go-playground/form"
)

type B struct {
	C string
	d interface{}
}

type A struct {
	B []B
}

func main() {
	d := form.NewDecoder()
	d.RegisterCustomTypeFunc(func(s []string) (interface{}, error) {
		b := B{}
		q, err := url.ParseQuery(s[0])
		if err != nil {
			return nil, err
		}
		b.C = q.Get("C")
		if b.C == "foo" {
			// obviously you could use d.Decode again, but this is an example
			b.d = struct {
				E string
			}{q.Get("E")}
		}
		return b, nil
	}, B{})

	q := url.Values{}
	q.Set("B[0].C", "foo")
	q.Set("B[0].E", "bar")
	a := &A{}
	d.Decode(a, q)
	// RegisterCustomTypeFunc is never called
	// a is &{B:[{C:foo d:<nil>}]}

	q = url.Values{}
	q.Set("B[0]", "C=foo&E=bar")
	a = &A{}
	d.Decode(a, q)
	// RegisterCustomTypeFunc is called
	// a is &{B:[{C:foo d:{E:bar}}]}
}

Say I have the following struct:

type User struct {
 Address Address
}

Am I able to decode form data to only the Address field? Like so:

decoder = form.NewDecoder()
r.ParseForm()
var user User

if err := decoder.Decode(&user.Address, r.Form); err != nil {
 panic(err)
}

Assuming the form data provided is in a suitable format for the User struct.

Hello,

I need to support an older version of an API which supported both application/json and application/x-www-form-urlencoded requests, and some of the request parameters had inconsistent types, e.g. it could be sent as a number or a numeric string. So in order to support both json and forms, as well as numeric strings and numbers, I changed the parameter type to interface{}, however, it is always decoded as nil, presumably because the form type and the target value type do not match (e.g. int/string != interface{}), but I would expect that if I have a parameter of type interface{}, and that parameter is found in the form, then it would store the value in the parameter, since it can hold anything.

Here is an example:

package main

import (
	"bytes"
	"net/url"
	"fmt"
	"io"
	"github.com/go-playground/form"
)

type V1Request struct {
	Application interface{} `json:"application"`
	DeviceModel string      `json:"deviceModel,omitempty"`
}

func UrlformConsumerFunc() func(reader io.Reader, v interface{}) error {
	// create a new form decoder
	decoder := form.NewDecoder()

	// change tag to json since it's added by default by goswagger
	decoder.SetTagName("json")

	return func(r io.Reader, v interface{}) error {
		buf := new(bytes.Buffer)
		buf.ReadFrom(r)

		values, err := url.ParseQuery(buf.String())
		if err != nil {
			return err
		}

		return decoder.Decode(v, values)
	}
}

func main() {
	consumer := UrlformConsumerFunc()
	req := V1Request{}

	query := bytes.NewBufferString("application=5&deviceModel=iPhone")
	consumer(query, &req)

	fmt.Printf("Converted value %#v\n", req)
}

The output of this will be:

Converted value main.V1Request{Application:interface {}(nil), DeviceModel:"iPhone"}

Is there any way to achieve this using the library?

Thanks!

What is the reason to feed custom decoder with slice of strings?

type DecodeCustomTypeFunc func([]string) (interface{}, error)

Decoder function is called at

func (d *decoder) setFieldByType(current reflect.Value, namespace []byte, idx int) (set bool) {

https://github.com/go-playground/form/blob/master/decoder.go#L191

If target field is a slice, setFieldByType is called in a loop with idx iterating through []string. Internally custom decoder is called with that full []string and without any mention of current idx.

How decoder function is expected to deal with multi-element input?

To me it seems correct code should be

	val, err := cf([]string{arr[idx]})

but then I'm not sure why decoder function needs to accept a slice.

func TestDecodeArrayBug33(t *testing.T) {
	var data struct {
		A [3]string
	}
	cases := []struct {
		values url.Values
		want   [3]string
	}{
		{url.Values{"A": {"10"}},
			[3]string{"10", "", ""}},   // Output: [10 10 10]
		{url.Values{"A": {"10", "20"}},
			[3]string{"10", "20", ""}}, // Output: [10 10 10]
		{url.Values{"A[1]": {"20"}},
			[3]string{"", "20", ""}},   // Output: [ 20 ]
		{url.Values{"A": {"10"}, "A[2]": {"30"}},
			[3]string{"10", "", "30"}}, // Output: [10 10 30]
	}
	for _, v := range cases {
		data.A = [3]string{}
		form.NewDecoder().Decode(&data, v.values)
		t.Log(data.A)
	}
}

In a HTML form, how do I represent a new (to be added) item for a slice?

I've tried name="Languages[].Country", where the index isn't defined. As well as providing an index that doesn't exist, neither seem to work.

It seems that Decode panics if it receives invalid input. It is not idiomatic go and should be refactored using return errors. Otherwise at least the behaviour should be documented so that the caller can guard it with recover.

I'm referring to this feature here:

Array honours the specified index. eg. if "Array[2]" is the only Array value passed down, it will be put at index 2; if array isn't big enough it will be expanded.

If a user submits a key like Array[1234567890], the application will allocate over 1G of memory just for this single request. Of course, no one is stopping users from putting an even higher number as an index.

This snippet demonstrates the problem:

package main

import (
    "log"
    "net/url"

    "github.com/go-playground/form"
)

type A struct {
    Array []int
}

func main() {
    decoder := form.NewDecoder()
    a := A{}
    err := decoder.Decode(&a, url.Values{"Array[1234567890]": {"42"}})
    if err != nil {
        log.Fatalln(err)
    }
    for {
    }
}

The RES usage of this application spikes to 1220MB.

Package version eg. v9, v10:

Issue, Question or Enhancement:

can you tell me, how can i use this for multipart files??

Code sample, to showcase or reproduce:

// Employee
type Employee struct {
	Name  string
	Image *multipart.FileHeader
}

// Employees
type Employees struct {
	Data []Employee
}

{
    "data": [
        {
            "name": "some name1",
            "image": "file1.jpg"
        },
        {
            "name": "some name2",
            "image": "file2.jpg"
        }
    ]
}

It seems that map types are not supported. E.g. map[interface{}]interface{} or map[string]string. Is this the expected behaviour?

Play

package main

import (
	"fmt"
	"github.com/go-playground/form"
	"net/url"
	"reflect"
)

func main() {
	dec := form.NewDecoder()

	req := url.Values{"a": []string{"a"}, "b": []string{"b"}, "c": []string{"1"}}

	v := map[interface{}]interface{}{
		"a": "",
		"b": "",
		"c": 0,
	}

	expected := map[interface{}]interface{}{
		"a": "a",
		"b": "b",
		"c": 1,
	}
	if err := dec.Decode(&v, req); err != nil {
		panic(err)
	}
	if !reflect.DeepEqual(v, expected) {
		fmt.Printf("expected\n %#v\n received\n %#v", expected, v)
	}
}

type Request struct {
	TestInt        *int        `form:"test_int"`
	TestString  *string   `form:"test_string"`
}

When providing empty value for "test_string" parameter(r.Form["test_string"]=""), Request.TestString will be not nil and set with the zero value "" as wanted.

But when "test_int" is provided with an empty string value(r.Form["test_int"]=""), Request.TestInt is still nil and shloud rather be set to the zero value 0.

It works great with Gorilla Schema

fv, _ := form.NewEncoder().Encode(map[string]string{"a": "b"})
fmt.Printf(`the str="%s"`+"\n", fv.Encode())

the str="%5Ba%5D=b"

i will httpPost(xxx, encodeIt(x))

Example:

type Form struct {
   Field []string `form:"field"`
}

form := Form{ Field: []string{"value1", "value2"} }

// vals is contains 'field': "value3", "value4"
_ := Decoder.Decode(&form, vals)

// form.Field contains now "value1", "value2", "value3", "value4".
// Excepted was only "value3", "value4"

If I decode the HTTP post values to this struct, the Field property gets appended by the values in the post data instead of replaced.

The use case is the following: I pre-fill the Form struct with data based on the DB entity. I use this struct also in the view template to render the values. If I would fill the Form struct after the decoding, it will override all the decoded fields if I not check every single field.

My logical expectation of the form decoder is:

• If the form field exists in the values, make sure the value match the decoded value (now it's appending string array, don't tested other kind of arrays/struct array)
• If not just leave the field how it is (works)

If same field exists both in parent and embedded struct and url.Values has value only for parent then decoder incorrect set embedded field to same value.

type Embed struct {
	A string
}
var data struct {
	A string
	Embed
}
form.NewDecoder().Decode(&data, url.Values{
	"A": {"one"},
})
fmt.Println(data.A, data.Embed.A)
// Output: one one

If we will add "Embed.A":{"two"} or keep only this one and remove "A": {"one"} then it'll work as expected.