Skip to content

Commit 2fbdfbb

Browse files
taowentaowen
committed
merge
2 parents 720ab8d + f2b4162 commit 2fbdfbb

File tree

5 files changed

+174
-24
lines changed

5 files changed

+174
-24
lines changed

‎api_tests/config_test.go

+128-1
Original file line numberDiff line numberDiff line change
@@ -2,9 +2,10 @@ package test
22

33
import (
44
"encoding/json"
5+
"testing"
6+
57
"github.com/json-iterator/go"
68
"github.com/stretchr/testify/require"
7-
"testing"
89
)
910

1011
func Test_use_number_for_unmarshal(t *testing.T) {
@@ -45,3 +46,129 @@ func Test_read_large_number_as_interface(t *testing.T) {
4546
should.Nil(err)
4647
should.Equal(`123456789123456789123456789`, output)
4748
}
49+
50+
type caseSensitiveStruct struct {
51+
A string `json:"a"`
52+
B string `json:"b,omitempty"`
53+
C *C `json:"C,omitempty"`
54+
}
55+
56+
type C struct {
57+
D int64 `json:"D,omitempty"`
58+
E *E `json:"e,omitempty"`
59+
}
60+
61+
type E struct {
62+
F string `json:"F,omitempty"`
63+
}
64+
65+
func Test_CaseSensitive(t *testing.T) {
66+
should := require.New(t)
67+
68+
testCases := []struct {
69+
input string
70+
expectedOutput string
71+
caseSensitive bool
72+
}{
73+
{
74+
input: `{"A":"foo","B":"bar"}`,
75+
expectedOutput: `{"a":"foo","b":"bar"}`,
76+
caseSensitive: false,
77+
},
78+
{
79+
input: `{"a":"foo","b":"bar"}`,
80+
expectedOutput: `{"a":"foo","b":"bar"}`,
81+
caseSensitive: true,
82+
},
83+
{
84+
input: `{"a":"foo","b":"bar","C":{"D":10}}`,
85+
expectedOutput: `{"a":"foo","b":"bar","C":{"D":10}}`,
86+
caseSensitive: true,
87+
},
88+
{
89+
input: `{"a":"foo","B":"bar","c":{"d":10}}`,
90+
expectedOutput: `{"a":"foo"}`,
91+
caseSensitive: true,
92+
},
93+
{
94+
input: `{"a":"foo","C":{"d":10}}`,
95+
expectedOutput: `{"a":"foo","C":{}}`,
96+
caseSensitive: true,
97+
},
98+
{
99+
input: `{"a":"foo","C":{"D":10,"e":{"f":"baz"}}}`,
100+
expectedOutput: `{"a":"foo","C":{"D":10,"e":{}}}`,
101+
caseSensitive: true,
102+
},
103+
{
104+
input: `{"a":"foo","C":{"D":10,"e":{"F":"baz"}}}`,
105+
expectedOutput: `{"a":"foo","C":{"D":10,"e":{"F":"baz"}}}`,
106+
caseSensitive: true,
107+
},
108+
{
109+
input: `{"A":"foo","c":{"d":10,"E":{"f":"baz"}}}`,
110+
expectedOutput: `{"a":"foo","C":{"D":10,"e":{"F":"baz"}}}`,
111+
caseSensitive: false,
112+
},
113+
}
114+
115+
for _, tc := range testCases {
116+
val := caseSensitiveStruct{}
117+
err := jsoniter.Config{CaseSensitive: tc.caseSensitive}.Froze().UnmarshalFromString(tc.input, &val)
118+
should.Nil(err)
119+
120+
output, err := jsoniter.MarshalToString(val)
121+
should.Nil(err)
122+
should.Equal(tc.expectedOutput, output)
123+
}
124+
}
125+
126+
type structWithElevenFields struct {
127+
A string `json:"A,omitempty"`
128+
B string `json:"B,omitempty"`
129+
C string `json:"C,omitempty"`
130+
D string `json:"d,omitempty"`
131+
E string `json:"e,omitempty"`
132+
F string `json:"f,omitempty"`
133+
G string `json:"g,omitempty"`
134+
H string `json:"h,omitempty"`
135+
I string `json:"i,omitempty"`
136+
J string `json:"j,omitempty"`
137+
K string `json:"k,omitempty"`
138+
}
139+
140+
func Test_CaseSensitive_MoreThanTenFields(t *testing.T) {
141+
should := require.New(t)
142+
143+
testCases := []struct {
144+
input string
145+
expectedOutput string
146+
caseSensitive bool
147+
}{
148+
{
149+
input: `{"A":"1","B":"2","C":"3","d":"4","e":"5","f":"6","g":"7","h":"8","i":"9","j":"10","k":"11"}`,
150+
expectedOutput: `{"A":"1","B":"2","C":"3","d":"4","e":"5","f":"6","g":"7","h":"8","i":"9","j":"10","k":"11"}`,
151+
caseSensitive: true,
152+
},
153+
{
154+
input: `{"a":"1","b":"2","c":"3","D":"4","E":"5","F":"6"}`,
155+
expectedOutput: `{"A":"1","B":"2","C":"3","d":"4","e":"5","f":"6"}`,
156+
caseSensitive: false,
157+
},
158+
{
159+
input: `{"A":"1","b":"2","d":"4","E":"5"}`,
160+
expectedOutput: `{"A":"1","d":"4"}`,
161+
caseSensitive: true,
162+
},
163+
}
164+
165+
for _, tc := range testCases {
166+
val := structWithElevenFields{}
167+
err := jsoniter.Config{CaseSensitive: tc.caseSensitive}.Froze().UnmarshalFromString(tc.input, &val)
168+
should.Nil(err)
169+
170+
output, err := jsoniter.MarshalToString(val)
171+
should.Nil(err)
172+
should.Equal(tc.expectedOutput, output)
173+
}
174+
}

‎config.go

+6-2
Original file line numberDiff line numberDiff line change
@@ -2,12 +2,13 @@ package jsoniter
22

33
import (
44
"encoding/json"
5-
"github.com/modern-go/concurrent"
6-
"github.com/modern-go/reflect2"
75
"io"
86
"reflect"
97
"sync"
108
"unsafe"
9+
10+
"github.com/modern-go/concurrent"
11+
"github.com/modern-go/reflect2"
1112
)
1213

1314
// Config customize how the API should behave.
@@ -23,6 +24,7 @@ type Config struct {
2324
OnlyTaggedField bool
2425
ValidateJsonRawMessage bool
2526
ObjectFieldMustBeSimpleString bool
27+
CaseSensitive bool
2628
}
2729

2830
// API the public interface of this package.
@@ -75,6 +77,7 @@ type frozenConfig struct {
7577
extensions []Extension
7678
streamPool *sync.Pool
7779
iteratorPool *sync.Pool
80+
caseSensitive bool
7881
}
7982

8083
func (cfg *frozenConfig) initCache() {
@@ -128,6 +131,7 @@ func (cfg Config) Froze() API {
128131
objectFieldMustBeSimpleString: cfg.ObjectFieldMustBeSimpleString,
129132
onlyTaggedField: cfg.OnlyTaggedField,
130133
disallowUnknownFields: cfg.DisallowUnknownFields,
134+
caseSensitive: cfg.CaseSensitive,
131135
}
132136
api.streamPool = &sync.Pool{
133137
New: func() interface{} {

‎iter_object.go

+8-4
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,7 @@ func (iter *Iterator) readFieldHash() int64 {
6060
if b == '\\' {
6161
iter.head = i
6262
for _, b := range iter.readStringSlowPath() {
63-
if 'A' <= b && b <= 'Z' {
63+
if 'A' <= b && b <= 'Z' && !iter.cfg.caseSensitive {
6464
b += 'a' - 'A'
6565
}
6666
hash ^= int64(b)
@@ -82,7 +82,7 @@ func (iter *Iterator) readFieldHash() int64 {
8282
}
8383
return hash
8484
}
85-
if 'A' <= b && b <= 'Z' {
85+
if 'A' <= b && b <= 'Z' && !iter.cfg.caseSensitive {
8686
b += 'a' - 'A'
8787
}
8888
hash ^= int64(b)
@@ -95,10 +95,14 @@ func (iter *Iterator) readFieldHash() int64 {
9595
}
9696
}
9797

98-
func calcHash(str string) int64 {
98+
func calcHash(str string, caseSensitive bool) int64 {
9999
hash := int64(0x811c9dc5)
100100
for _, b := range str {
101-
hash ^= int64(unicode.ToLower(b))
101+
if caseSensitive {
102+
hash ^= int64(b)
103+
} else {
104+
hash ^= int64(unicode.ToLower(b))
105+
}
102106
hash *= 0x1000193
103107
}
104108
return int64(hash)

‎reflect.go

+10-1
Original file line numberDiff line numberDiff line change
@@ -2,9 +2,10 @@ package jsoniter
22

33
import (
44
"fmt"
5-
"github.com/modern-go/reflect2"
65
"reflect"
76
"unsafe"
7+
8+
"github.com/modern-go/reflect2"
89
)
910

1011
// ValDecoder is an internal type registered to cache as needed.
@@ -40,6 +41,14 @@ type ctx struct {
4041
decoders map[reflect2.Type]ValDecoder
4142
}
4243

44+
func (b *ctx) caseSensitive() bool {
45+
if b.frozenConfig == nil {
46+
// default is case-insensitive
47+
return false
48+
}
49+
return b.frozenConfig.caseSensitive
50+
}
51+
4352
func (b *ctx) append(prefix string) *ctx {
4453
return &ctx{
4554
frozenConfig: b.frozenConfig,

‎reflect_struct_decoder.go

+22-16
Original file line numberDiff line numberDiff line change
@@ -2,10 +2,11 @@ package jsoniter
22

33
import (
44
"fmt"
5-
"github.com/modern-go/reflect2"
65
"io"
76
"strings"
87
"unsafe"
8+
9+
"github.com/modern-go/reflect2"
910
)
1011

1112
func decoderOfStruct(ctx *ctx, typ reflect2.Type) ValDecoder {
@@ -31,11 +32,15 @@ func decoderOfStruct(ctx *ctx, typ reflect2.Type) ValDecoder {
3132
for k, binding := range bindings {
3233
fields[k] = binding.Decoder.(*structFieldDecoder)
3334
}
34-
for k, binding := range bindings {
35-
if _, found := fields[strings.ToLower(k)]; !found {
36-
fields[strings.ToLower(k)] = binding.Decoder.(*structFieldDecoder)
35+
36+
if !ctx.caseSensitive() {
37+
for k, binding := range bindings {
38+
if _, found := fields[strings.ToLower(k)]; !found {
39+
fields[strings.ToLower(k)] = binding.Decoder.(*structFieldDecoder)
40+
}
3741
}
3842
}
43+
3944
return createStructDecoder(ctx, typ, fields)
4045
}
4146

@@ -46,12 +51,13 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
4651
knownHash := map[int64]struct{}{
4752
0: {},
4853
}
54+
4955
switch len(fields) {
5056
case 0:
5157
return &skipObjectDecoder{typ}
5258
case 1:
5359
for fieldName, fieldDecoder := range fields {
54-
fieldHash := calcHash(fieldName)
60+
fieldHash := calcHash(fieldName, ctx.caseSensitive())
5561
_, known := knownHash[fieldHash]
5662
if known {
5763
return &generalStructDecoder{typ, fields, false}
@@ -65,7 +71,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
6571
var fieldDecoder1 *structFieldDecoder
6672
var fieldDecoder2 *structFieldDecoder
6773
for fieldName, fieldDecoder := range fields {
68-
fieldHash := calcHash(fieldName)
74+
fieldHash := calcHash(fieldName, ctx.caseSensitive())
6975
_, known := knownHash[fieldHash]
7076
if known {
7177
return &generalStructDecoder{typ, fields, false}
@@ -88,7 +94,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
8894
var fieldDecoder2 *structFieldDecoder
8995
var fieldDecoder3 *structFieldDecoder
9096
for fieldName, fieldDecoder := range fields {
91-
fieldHash := calcHash(fieldName)
97+
fieldHash := calcHash(fieldName, ctx.caseSensitive())
9298
_, known := knownHash[fieldHash]
9399
if known {
94100
return &generalStructDecoder{typ, fields, false}
@@ -119,7 +125,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
119125
var fieldDecoder3 *structFieldDecoder
120126
var fieldDecoder4 *structFieldDecoder
121127
for fieldName, fieldDecoder := range fields {
122-
fieldHash := calcHash(fieldName)
128+
fieldHash := calcHash(fieldName, ctx.caseSensitive())
123129
_, known := knownHash[fieldHash]
124130
if known {
125131
return &generalStructDecoder{typ, fields, false}
@@ -156,7 +162,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
156162
var fieldDecoder4 *structFieldDecoder
157163
var fieldDecoder5 *structFieldDecoder
158164
for fieldName, fieldDecoder := range fields {
159-
fieldHash := calcHash(fieldName)
165+
fieldHash := calcHash(fieldName, ctx.caseSensitive())
160166
_, known := knownHash[fieldHash]
161167
if known {
162168
return &generalStructDecoder{typ, fields, false}
@@ -199,7 +205,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
199205
var fieldDecoder5 *structFieldDecoder
200206
var fieldDecoder6 *structFieldDecoder
201207
for fieldName, fieldDecoder := range fields {
202-
fieldHash := calcHash(fieldName)
208+
fieldHash := calcHash(fieldName, ctx.caseSensitive())
203209
_, known := knownHash[fieldHash]
204210
if known {
205211
return &generalStructDecoder{typ, fields, false}
@@ -248,7 +254,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
248254
var fieldDecoder6 *structFieldDecoder
249255
var fieldDecoder7 *structFieldDecoder
250256
for fieldName, fieldDecoder := range fields {
251-
fieldHash := calcHash(fieldName)
257+
fieldHash := calcHash(fieldName, ctx.caseSensitive())
252258
_, known := knownHash[fieldHash]
253259
if known {
254260
return &generalStructDecoder{typ, fields, false}
@@ -303,7 +309,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
303309
var fieldDecoder7 *structFieldDecoder
304310
var fieldDecoder8 *structFieldDecoder
305311
for fieldName, fieldDecoder := range fields {
306-
fieldHash := calcHash(fieldName)
312+
fieldHash := calcHash(fieldName, ctx.caseSensitive())
307313
_, known := knownHash[fieldHash]
308314
if known {
309315
return &generalStructDecoder{typ, fields, false}
@@ -364,7 +370,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
364370
var fieldDecoder8 *structFieldDecoder
365371
var fieldDecoder9 *structFieldDecoder
366372
for fieldName, fieldDecoder := range fields {
367-
fieldHash := calcHash(fieldName)
373+
fieldHash := calcHash(fieldName, ctx.caseSensitive())
368374
_, known := knownHash[fieldHash]
369375
if known {
370376
return &generalStructDecoder{typ, fields, false}
@@ -431,7 +437,7 @@ func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structF
431437
var fieldDecoder9 *structFieldDecoder
432438
var fieldDecoder10 *structFieldDecoder
433439
for fieldName, fieldDecoder := range fields {
434-
fieldHash := calcHash(fieldName)
440+
fieldHash := calcHash(fieldName, ctx.caseSensitive())
435441
_, known := knownHash[fieldHash]
436442
if known {
437443
return &generalStructDecoder{typ, fields, false}
@@ -513,13 +519,13 @@ func (decoder *generalStructDecoder) decodeOneField(ptr unsafe.Pointer, iter *It
513519
fieldBytes := iter.ReadStringAsSlice()
514520
field = *(*string)(unsafe.Pointer(&fieldBytes))
515521
fieldDecoder = decoder.fields[field]
516-
if fieldDecoder == nil {
522+
if fieldDecoder == nil && !iter.cfg.caseSensitive {
517523
fieldDecoder = decoder.fields[strings.ToLower(field)]
518524
}
519525
} else {
520526
field = iter.ReadString()
521527
fieldDecoder = decoder.fields[field]
522-
if fieldDecoder == nil {
528+
if fieldDecoder == nil && !iter.cfg.caseSensitive {
523529
fieldDecoder = decoder.fields[strings.ToLower(field)]
524530
}
525531
}

0 commit comments

Comments
 (0)