patch: add CaseSensitive decoder option

This adds a CaseSensitive decoder option (defaulting to false).

When decoding a JSON object to a struct, JSON keys are treated case-sensitively
when locating corresponding struct fields. Keys must exactly match `json` tag names
(for tagged struct fields) or struct field names (for untagged struct fields),
or are treated as unknown fields.

Author: liggitt

internal/golang/encoding/json/decode.go

@@ -234,6 +234,8 @@ type decodeState struct {
 
 	savedStrictErrors []error
 	seenStrictErrors  map[string]struct{}
+
+	caseSensitive bool
 }
 
 // readIndex returns the position of the last byte read.
@@ -720,7 +722,7 @@ func (d *decodeState) object(v reflect.Value) error {
 			if i, ok := fields.nameIndex[string(key)]; ok {
 				// Found an exact name match.
 				f = &fields.list[i]
-			} else {
+			} else if !d.caseSensitive {
 				// Fall back to the expensive case-insensitive
 				// linear search.
 				for i := range fields.list {

internal/golang/encoding/json/kubernetes_patch.go

@@ -40,6 +40,15 @@ func DisallowUnknownFields(d *decodeState) {
 	d.disallowUnknownFields = true
 }
 
+// CaseSensitive requires json keys to exactly match specified json tags (for tagged struct fields)
+// or struct field names (for untagged struct fields), or be treated as an unknown field.
+func CaseSensitive(d *decodeState) {
+	d.caseSensitive = true
+}
+func (d *Decoder) CaseSensitive() {
+	d.d.caseSensitive = true
+}
+
 // saveStrictError saves a strict decoding error,
 // for reporting at the end of the unmarshal if no other errors occurred.
 func (d *decodeState) saveStrictError(err error) {

internal/golang/encoding/json/kubernetes_patch_test.go

@@ -165,3 +165,100 @@ func TestStrictErrors(t *testing.T) {
 		})
 	}
 }
+
+func TestCaseSensitive(t *testing.T) {
+	type Embedded1 struct {
+		C int `json:"c"`
+		D int
+	}
+	type Embedded2 struct {
+		E int `json:"e"`
+		F int
+	}
+
+	type Obj struct {
+		A         int `json:"a"`
+		B         int
+		Embedded1 `json:",inline"`
+		Embedded2
+	}
+
+	testcases := []struct {
+		name   string
+		in     string
+		to     interface{}
+		expect interface{}
+	}{
+		{
+			name:   "tagged",
+			in:     `{"A":"1","A":2,"a":3,"A":4,"A":"5"}`,
+			to:     &Obj{},
+			expect: &Obj{A: 3},
+		},
+		{
+			name:   "untagged",
+			in:     `{"b":"1","b":2,"B":3,"b":4,"b":"5"}`,
+			to:     &Obj{},
+			expect: &Obj{B: 3},
+		},
+		{
+			name:   "inline embedded tagged subfield",
+			in:     `{"C":"1","C":2,"c":3,"C":4,"C":"5"}`,
+			to:     &Obj{},
+			expect: &Obj{Embedded1: Embedded1{C: 3}},
+		},
+		{
+			name:   "inline embedded untagged subfield",
+			in:     `{"d":"1","d":2,"D":3,"d":4,"d":"5"}`,
+			to:     &Obj{},
+			expect: &Obj{Embedded1: Embedded1{D: 3}},
+		},
+		{
+			name:   "inline embedded field name",
+			in:     `{"Embedded1":{"c":3}}`,
+			to:     &Obj{},
+			expect: &Obj{}, // inlined embedded is not addressable by field name
+		},
+		{
+			name:   "inline embedded empty name",
+			in:     `{"":{"c":3}}`,
+			to:     &Obj{},
+			expect: &Obj{}, // inlined embedded is not addressable by empty json field name
+		},
+		{
+			name:   "untagged embedded tagged subfield",
+			in:     `{"E":"1","E":2,"e":3,"E":4,"E":"5"}`,
+			to:     &Obj{},
+			expect: &Obj{Embedded2: Embedded2{E: 3}},
+		},
+		{
+			name:   "untagged embedded untagged subfield",
+			in:     `{"f":"1","f":2,"F":3,"f":4,"f":"5"}`,
+			to:     &Obj{},
+			expect: &Obj{Embedded2: Embedded2{F: 3}},
+		},
+		{
+			name:   "untagged embedded field name",
+			in:     `{"Embedded2":{"e":3}}`,
+			to:     &Obj{},
+			expect: &Obj{}, // untagged embedded is not addressable by field name
+		},
+		{
+			name:   "untagged embedded empty name",
+			in:     `{"":{"e":3}}`,
+			to:     &Obj{},
+			expect: &Obj{}, // untagged embedded is not addressable by empty json field name
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			if err := Unmarshal([]byte(tc.in), &tc.to, CaseSensitive); err != nil {
+				t.Fatal(err)
+			}
+			if !reflect.DeepEqual(tc.expect, tc.to) {
+				t.Fatalf("expected\n%#v\ngot\n%#v", tc.expect, tc.to)
+			}
+		})
+	}
+}