feat: support user use specify tag

game1991 · game1991 · commit 9ef81866d0cc · 2023-06-05T15:13:31.000+08:00
diff --git a/README.md b/README.md
@@ -27,7 +27,7 @@ type Options struct {
 }
 
 opt := Options{ "foo", true, 2 }
-v, _ := query.Values(opt)
+v, _ := query.Values("",opt)
 fmt.Print(v.Encode()) // will output: "q=foo&all=true&page=2"
 ```
 
diff --git a/query/encode.go b/query/encode.go
@@ -123,7 +123,10 @@ type Encoder interface {
 //
 // Multiple fields that encode to the same URL parameter name will be included
 // as multiple URL values of the same name.
-func Values(v interface{}) (url.Values, error) {
+func Values(userTag string, v interface{}) (url.Values, error) {
+	if userTag == "" {
+		userTag = "url" // default tag
+	}
 	values := make(url.Values)
 	val := reflect.ValueOf(v)
 	for val.Kind() == reflect.Ptr {
@@ -141,14 +144,14 @@ func Values(v interface{}) (url.Values, error) {
 		return nil, fmt.Errorf("query: Values() expects struct input. Got %v", val.Kind())
 	}
 
-	err := reflectValue(values, val, "")
+	err := reflectValue(userTag, values, val, "")
 	return values, err
 }
 
 // reflectValue populates the values parameter from the struct fields in val.
 // Embedded structs are followed recursively (using the rules defined in the
 // Values function documentation) breadth-first.
-func reflectValue(values url.Values, val reflect.Value, scope string) error {
+func reflectValue(userTag string, values url.Values, val reflect.Value, scope string) error {
 	var embedded []reflect.Value
 
 	typ := val.Type()
@@ -159,7 +162,7 @@ func reflectValue(values url.Values, val reflect.Value, scope string) error {
 		}
 
 		sv := val.Field(i)
-		tag := sf.Tag.Get("url")
+		tag := sf.Tag.Get(userTag)
 		if tag == "-" {
 			continue
 		}
@@ -257,7 +260,7 @@ func reflectValue(values url.Values, val reflect.Value, scope string) error {
 		}
 
 		if sv.Kind() == reflect.Struct {
-			if err := reflectValue(values, sv, name); err != nil {
+			if err := reflectValue(userTag, values, sv, name); err != nil {
 				return err
 			}
 			continue
@@ -267,7 +270,7 @@ func reflectValue(values url.Values, val reflect.Value, scope string) error {
 	}
 
 	for _, f := range embedded {
-		if err := reflectValue(values, f, scope); err != nil {
+		if err := reflectValue(userTag, values, f, scope); err != nil {
 			return err
 		}
 	}
diff --git a/query/encode_test.go b/query/encode_test.go
@@ -16,8 +16,8 @@ import (
 )
 
 // test that Values(input) matches want.  If not, report an error on t.
-func testValue(t *testing.T, input interface{}, want url.Values) {
-	v, err := Values(input)
+func testValue(t *testing.T, userTag string, input interface{}, want url.Values) {
+	v, err := Values(userTag, input)
 	if err != nil {
 		t.Errorf("Values(%q) returned error: %v", input, err)
 	}
@@ -28,31 +28,34 @@ func testValue(t *testing.T, input interface{}, want url.Values) {
 
 func TestValues_BasicTypes(t *testing.T) {
 	tests := []struct {
+		myTag string
 		input interface{}
 		want  url.Values
 	}{
 		// zero values
-		{struct{ V string }{}, url.Values{"V": {""}}},
-		{struct{ V int }{}, url.Values{"V": {"0"}}},
-		{struct{ V uint }{}, url.Values{"V": {"0"}}},
-		{struct{ V float32 }{}, url.Values{"V": {"0"}}},
-		{struct{ V bool }{}, url.Values{"V": {"false"}}},
+		{"userTag", struct{ V string }{}, url.Values{"V": {""}}},
+		{"userTag", struct{ V int }{}, url.Values{"V": {"0"}}},
+		{"userTag", struct{ V uint }{}, url.Values{"V": {"0"}}},
+		{"userTag", struct{ V float32 }{}, url.Values{"V": {"0"}}},
+		{"userTag", struct{ V bool }{}, url.Values{"V": {"false"}}},
 
 		// simple non-zero values
-		{struct{ V string }{"v"}, url.Values{"V": {"v"}}},
-		{struct{ V int }{1}, url.Values{"V": {"1"}}},
-		{struct{ V uint }{1}, url.Values{"V": {"1"}}},
-		{struct{ V float32 }{0.1}, url.Values{"V": {"0.1"}}},
-		{struct{ V bool }{true}, url.Values{"V": {"true"}}},
+		{"userTag", struct{ V string }{"v"}, url.Values{"V": {"v"}}},
+		{"userTag", struct{ V int }{1}, url.Values{"V": {"1"}}},
+		{"userTag", struct{ V uint }{1}, url.Values{"V": {"1"}}},
+		{"userTag", struct{ V float32 }{0.1}, url.Values{"V": {"0.1"}}},
+		{"userTag", struct{ V bool }{true}, url.Values{"V": {"true"}}},
 
 		// bool-specific options
 		{
+			"url",
 			struct {
 				V bool `url:",int"`
 			}{false},
 			url.Values{"V": {"0"}},
 		},
 		{
+			"url",
 			struct {
 				V bool `url:",int"`
 			}{true},
@@ -61,30 +64,35 @@ func TestValues_BasicTypes(t *testing.T) {
 
 		// time values
 		{
+			"",
 			struct {
 				V time.Time
 			}{time.Date(2000, 1, 1, 12, 34, 56, 0, time.UTC)},
 			url.Values{"V": {"2000-01-01T12:34:56Z"}},
 		},
 		{
+			"url",
 			struct {
 				V time.Time `url:",unix"`
 			}{time.Date(2000, 1, 1, 12, 34, 56, 0, time.UTC)},
 			url.Values{"V": {"946730096"}},
 		},
 		{
+			"url",
 			struct {
 				V time.Time `url:",unixmilli"`
 			}{time.Date(2000, 1, 1, 12, 34, 56, 0, time.UTC)},
 			url.Values{"V": {"946730096000"}},
 		},
 		{
+			"url",
 			struct {
 				V time.Time `url:",unixnano"`
 			}{time.Date(2000, 1, 1, 12, 34, 56, 0, time.UTC)},
 			url.Values{"V": {"946730096000000000"}},
 		},
 		{
+			"url",
 			struct {
 				V time.Time `layout:"2006-01-02"`
 			}{time.Date(2000, 1, 1, 12, 34, 56, 0, time.UTC)},
@@ -93,7 +101,7 @@ func TestValues_BasicTypes(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		testValue(t, tt.input, tt.want)
+		testValue(t, tt.myTag, tt.input, tt.want)
 	}
 }
 
@@ -129,7 +137,7 @@ func TestValues_Pointers(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		testValue(t, tt.input, tt.want)
+		testValue(t, "url", tt.input, tt.want)
 	}
 }
 
@@ -268,7 +276,7 @@ func TestValues_Slices(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		testValue(t, tt.input, tt.want)
+		testValue(t, "url", tt.input, tt.want)
 	}
 }
 
@@ -325,7 +333,7 @@ func TestValues_NestedTypes(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		testValue(t, tt.input, tt.want)
+		testValue(t, "url", tt.input, tt.want)
 	}
 }
 
@@ -365,7 +373,7 @@ func TestValues_OmitEmpty(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		testValue(t, tt.input, tt.want)
+		testValue(t, "url", tt.input, tt.want)
 	}
 }
 
@@ -420,12 +428,12 @@ func TestValues_EmbeddedStructs(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		testValue(t, tt.input, tt.want)
+		testValue(t, "url", tt.input, tt.want)
 	}
 }
 
 func TestValues_InvalidInput(t *testing.T) {
-	_, err := Values("")
+	_, err := Values("", "")
 	if err == nil {
 		t.Errorf("expected Values() to return an error on invalid input")
 	}
@@ -480,7 +488,7 @@ func TestValues_CustomEncodingSlice(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		testValue(t, tt.input, tt.want)
+		testValue(t, "", tt.input, tt.want)
 	}
 }
 
@@ -504,7 +512,7 @@ func TestValues_CustomEncoding_Error(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		_, err := Values(tt.input)
+		_, err := Values("", tt.input)
 		if err == nil {
 			t.Errorf("Values(%q) did not return expected encoding error", tt.input)
 		}
@@ -574,7 +582,7 @@ func TestValues_CustomEncodingInt(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		testValue(t, tt.input, tt.want)
+		testValue(t, "", tt.input, tt.want)
 	}
 }
 
@@ -657,7 +665,7 @@ func TestValues_CustomEncodingPointer(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		testValue(t, tt.input, tt.want)
+		testValue(t, "", tt.input, tt.want)
 	}
 }
 

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ type Options struct {`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`opt := Options{ "foo", true, 2 }`
`30`		`-v, _ := query.Values(opt)`
	`30`	`+v, _ := query.Values("",opt)`
`31`	`31`	`fmt.Print(v.Encode()) // will output: "q=foo&all=true&page=2"`
`32`	`32`	```
`33`	`33`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,10 @@ type Encoder interface {`
`123`	`123`	`//`
`124`	`124`	`// Multiple fields that encode to the same URL parameter name will be included`
`125`	`125`	`// as multiple URL values of the same name.`
`126`		`-func Values(v interface{}) (url.Values, error) {`
	`126`	`+func Values(userTag string, v interface{}) (url.Values, error) {`
	`127`	`+ if userTag == "" {`
	`128`	`+ userTag = "url" // default tag`
	`129`	`+ }`
`127`	`130`	`values := make(url.Values)`
`128`	`131`	`val := reflect.ValueOf(v)`
`129`	`132`	`for val.Kind() == reflect.Ptr {`
`@@ -141,14 +144,14 @@ func Values(v interface{}) (url.Values, error) {`
`141`	`144`	`return nil, fmt.Errorf("query: Values() expects struct input. Got %v", val.Kind())`
`142`	`145`	`}`
`143`	`146`
`144`		`- err := reflectValue(values, val, "")`
	`147`	`+ err := reflectValue(userTag, values, val, "")`
`145`	`148`	`return values, err`
`146`	`149`	`}`
`147`	`150`
`148`	`151`	`// reflectValue populates the values parameter from the struct fields in val.`
`149`	`152`	`// Embedded structs are followed recursively (using the rules defined in the`
`150`	`153`	`// Values function documentation) breadth-first.`
`151`		`-func reflectValue(values url.Values, val reflect.Value, scope string) error {`
	`154`	`+func reflectValue(userTag string, values url.Values, val reflect.Value, scope string) error {`
`152`	`155`	`var embedded []reflect.Value`
`153`	`156`
`154`	`157`	`typ := val.Type()`
`@@ -159,7 +162,7 @@ func reflectValue(values url.Values, val reflect.Value, scope string) error {`
`159`	`162`	`}`
`160`	`163`
`161`	`164`	`sv := val.Field(i)`
`162`		`- tag := sf.Tag.Get("url")`
	`165`	`+ tag := sf.Tag.Get(userTag)`
`163`	`166`	`if tag == "-" {`
`164`	`167`	`continue`
`165`	`168`	`}`
`@@ -257,7 +260,7 @@ func reflectValue(values url.Values, val reflect.Value, scope string) error {`
`257`	`260`	`}`
`258`	`261`
`259`	`262`	`if sv.Kind() == reflect.Struct {`
`260`		`- if err := reflectValue(values, sv, name); err != nil {`
	`263`	`+ if err := reflectValue(userTag, values, sv, name); err != nil {`
`261`	`264`	`return err`
`262`	`265`	`}`
`263`	`266`	`continue`
`@@ -267,7 +270,7 @@ func reflectValue(values url.Values, val reflect.Value, scope string) error {`
`267`	`270`	`}`
`268`	`271`
`269`	`272`	`for _, f := range embedded {`
`270`		`- if err := reflectValue(values, f, scope); err != nil {`
	`273`	`+ if err := reflectValue(userTag, values, f, scope); err != nil {`
`271`	`274`	`return err`
`272`	`275`	`}`
`273`	`276`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,8 +16,8 @@ import (`
`16`	`16`	`)`
`17`	`17`
`18`	`18`	`// test that Values(input) matches want. If not, report an error on t.`
`19`		`-func testValue(t *testing.T, input interface{}, want url.Values) {`
`20`		`- v, err := Values(input)`
	`19`	`+func testValue(t *testing.T, userTag string, input interface{}, want url.Values) {`
	`20`	`+ v, err := Values(userTag, input)`
`21`	`21`	`if err != nil {`
`22`	`22`	`t.Errorf("Values(%q) returned error: %v", input, err)`
`23`	`23`	`}`
`@@ -28,31 +28,34 @@ func testValue(t *testing.T, input interface{}, want url.Values) {`
`28`	`28`
`29`	`29`	`func TestValues_BasicTypes(t *testing.T) {`
`30`	`30`	`tests := []struct {`
	`31`	`+ myTag string`
`31`	`32`	`input interface{}`
`32`	`33`	`want url.Values`
`33`	`34`	`}{`
`34`	`35`	`// zero values`
`35`		`- {struct{ V string }{}, url.Values{"V": {""}}},`
`36`		`- {struct{ V int }{}, url.Values{"V": {"0"}}},`
`37`		`- {struct{ V uint }{}, url.Values{"V": {"0"}}},`
`38`		`- {struct{ V float32 }{}, url.Values{"V": {"0"}}},`
`39`		`- {struct{ V bool }{}, url.Values{"V": {"false"}}},`
	`36`	`+ {"userTag", struct{ V string }{}, url.Values{"V": {""}}},`
	`37`	`+ {"userTag", struct{ V int }{}, url.Values{"V": {"0"}}},`
	`38`	`+ {"userTag", struct{ V uint }{}, url.Values{"V": {"0"}}},`
	`39`	`+ {"userTag", struct{ V float32 }{}, url.Values{"V": {"0"}}},`
	`40`	`+ {"userTag", struct{ V bool }{}, url.Values{"V": {"false"}}},`
`40`	`41`
`41`	`42`	`// simple non-zero values`
`42`		`- {struct{ V string }{"v"}, url.Values{"V": {"v"}}},`
`43`		`- {struct{ V int }{1}, url.Values{"V": {"1"}}},`
`44`		`- {struct{ V uint }{1}, url.Values{"V": {"1"}}},`
`45`		`- {struct{ V float32 }{0.1}, url.Values{"V": {"0.1"}}},`
`46`		`- {struct{ V bool }{true}, url.Values{"V": {"true"}}},`
	`43`	`+ {"userTag", struct{ V string }{"v"}, url.Values{"V": {"v"}}},`
	`44`	`+ {"userTag", struct{ V int }{1}, url.Values{"V": {"1"}}},`
	`45`	`+ {"userTag", struct{ V uint }{1}, url.Values{"V": {"1"}}},`
	`46`	`+ {"userTag", struct{ V float32 }{0.1}, url.Values{"V": {"0.1"}}},`
	`47`	`+ {"userTag", struct{ V bool }{true}, url.Values{"V": {"true"}}},`
`47`	`48`
`48`	`49`	`// bool-specific options`
`49`	`50`	`{`
	`51`	`+ "url",`
`50`	`52`	`struct {`
`51`	`53`	V bool `url:",int"`
`52`	`54`	`}{false},`
`53`	`55`	`url.Values{"V": {"0"}},`
`54`	`56`	`},`
`55`	`57`	`{`
	`58`	`+ "url",`
`56`	`59`	`struct {`
`57`	`60`	V bool `url:",int"`
`58`	`61`	`}{true},`
`@@ -61,30 +64,35 @@ func TestValues_BasicTypes(t *testing.T) {`
`61`	`64`
`62`	`65`	`// time values`
`63`	`66`	`{`
	`67`	`+ "",`
`64`	`68`	`struct {`
`65`	`69`	`V time.Time`
`66`	`70`	`}{time.Date(2000, 1, 1, 12, 34, 56, 0, time.UTC)},`
`67`	`71`	`url.Values{"V": {"2000-01-01T12:34:56Z"}},`
`68`	`72`	`},`
`69`	`73`	`{`
	`74`	`+ "url",`
`70`	`75`	`struct {`
`71`	`76`	V time.Time `url:",unix"`
`72`	`77`	`}{time.Date(2000, 1, 1, 12, 34, 56, 0, time.UTC)},`
`73`	`78`	`url.Values{"V": {"946730096"}},`
`74`	`79`	`},`
`75`	`80`	`{`
	`81`	`+ "url",`
`76`	`82`	`struct {`
`77`	`83`	V time.Time `url:",unixmilli"`
`78`	`84`	`}{time.Date(2000, 1, 1, 12, 34, 56, 0, time.UTC)},`
`79`	`85`	`url.Values{"V": {"946730096000"}},`
`80`	`86`	`},`
`81`	`87`	`{`
	`88`	`+ "url",`
`82`	`89`	`struct {`
`83`	`90`	V time.Time `url:",unixnano"`
`84`	`91`	`}{time.Date(2000, 1, 1, 12, 34, 56, 0, time.UTC)},`
`85`	`92`	`url.Values{"V": {"946730096000000000"}},`
`86`	`93`	`},`
`87`	`94`	`{`
	`95`	`+ "url",`
`88`	`96`	`struct {`
`89`	`97`	V time.Time `layout:"2006-01-02"`
`90`	`98`	`}{time.Date(2000, 1, 1, 12, 34, 56, 0, time.UTC)},`
`@@ -93,7 +101,7 @@ func TestValues_BasicTypes(t *testing.T) {`
`93`	`101`	`}`
`94`	`102`
`95`	`103`	`for _, tt := range tests {`
`96`		`- testValue(t, tt.input, tt.want)`
	`104`	`+ testValue(t, tt.myTag, tt.input, tt.want)`
`97`	`105`	`}`
`98`	`106`	`}`
`99`	`107`
`@@ -129,7 +137,7 @@ func TestValues_Pointers(t *testing.T) {`
`129`	`137`	`}`
`130`	`138`
`131`	`139`	`for _, tt := range tests {`
`132`		`- testValue(t, tt.input, tt.want)`
	`140`	`+ testValue(t, "url", tt.input, tt.want)`
`133`	`141`	`}`
`134`	`142`	`}`
`135`	`143`
`@@ -268,7 +276,7 @@ func TestValues_Slices(t *testing.T) {`
`268`	`276`	`}`
`269`	`277`
`270`	`278`	`for _, tt := range tests {`
`271`		`- testValue(t, tt.input, tt.want)`
	`279`	`+ testValue(t, "url", tt.input, tt.want)`
`272`	`280`	`}`
`273`	`281`	`}`
`274`	`282`
`@@ -325,7 +333,7 @@ func TestValues_NestedTypes(t *testing.T) {`
`325`	`333`	`}`
`326`	`334`
`327`	`335`	`for _, tt := range tests {`
`328`		`- testValue(t, tt.input, tt.want)`
	`336`	`+ testValue(t, "url", tt.input, tt.want)`
`329`	`337`	`}`
`330`	`338`	`}`
`331`	`339`
`@@ -365,7 +373,7 @@ func TestValues_OmitEmpty(t *testing.T) {`
`365`	`373`	`}`
`366`	`374`
`367`	`375`	`for _, tt := range tests {`
`368`		`- testValue(t, tt.input, tt.want)`
	`376`	`+ testValue(t, "url", tt.input, tt.want)`
`369`	`377`	`}`
`370`	`378`	`}`
`371`	`379`
`@@ -420,12 +428,12 @@ func TestValues_EmbeddedStructs(t *testing.T) {`
`420`	`428`	`}`
`421`	`429`
`422`	`430`	`for _, tt := range tests {`
`423`		`- testValue(t, tt.input, tt.want)`
	`431`	`+ testValue(t, "url", tt.input, tt.want)`
`424`	`432`	`}`
`425`	`433`	`}`
`426`	`434`
`427`	`435`	`func TestValues_InvalidInput(t *testing.T) {`
`428`		`- _, err := Values("")`
	`436`	`+ _, err := Values("", "")`
`429`	`437`	`if err == nil {`
`430`	`438`	`t.Errorf("expected Values() to return an error on invalid input")`
`431`	`439`	`}`
`@@ -480,7 +488,7 @@ func TestValues_CustomEncodingSlice(t *testing.T) {`
`480`	`488`	`}`
`481`	`489`
`482`	`490`	`for _, tt := range tests {`
`483`		`- testValue(t, tt.input, tt.want)`
	`491`	`+ testValue(t, "", tt.input, tt.want)`
`484`	`492`	`}`
`485`	`493`	`}`
`486`	`494`
`@@ -504,7 +512,7 @@ func TestValues_CustomEncoding_Error(t *testing.T) {`
`504`	`512`	`},`
`505`	`513`	`}`
`506`	`514`	`for _, tt := range tests {`
`507`		`- _, err := Values(tt.input)`
	`515`	`+ _, err := Values("", tt.input)`
`508`	`516`	`if err == nil {`
`509`	`517`	`t.Errorf("Values(%q) did not return expected encoding error", tt.input)`
`510`	`518`	`}`
`@@ -574,7 +582,7 @@ func TestValues_CustomEncodingInt(t *testing.T) {`
`574`	`582`	`}`
`575`	`583`
`576`	`584`	`for _, tt := range tests {`
`577`		`- testValue(t, tt.input, tt.want)`
	`585`	`+ testValue(t, "", tt.input, tt.want)`
`578`	`586`	`}`
`579`	`587`	`}`
`580`	`588`
`@@ -657,7 +665,7 @@ func TestValues_CustomEncodingPointer(t *testing.T) {`
`657`	`665`	`}`
`658`	`666`
`659`	`667`	`for _, tt := range tests {`
`660`		`- testValue(t, tt.input, tt.want)`
	`668`	`+ testValue(t, "", tt.input, tt.want)`
`661`	`669`	`}`
`662`	`670`	`}`
`663`	`671`