Merge pull request #40 from francoispqt/feature/generator

Feature/generator

Author: francoispqt

.travis.yml

@@ -6,6 +6,7 @@ go:
 
 script:
   - go get github.com/stretchr/testify
+  - go test ./gojay -race
   - go test -race -coverprofile=coverage.txt -covermode=atomic
 
 after_success:

README.md

@@ -8,12 +8,17 @@
 ![stability-stable](https://img.shields.io/badge/stability-stable-green.svg)
 
 # GoJay
+
+<img src="https://github.com/francoispqt/gojay/raw/feature/generator/gojay.png" width="200px">
+
 GoJay is a performant JSON encoder/decoder for Golang (currently the most performant, [see benchmarks](#benchmark-results)). 
 
 It has a simple API and doesn't use reflection. It relies on small interfaces to decode/encode structures and slices. 
 
 Gojay also comes with powerful stream decoding features and an even faster [Unsafe](#unsafe-api) API.
 
+There is also a [code generation tool](https://github.com/francoispqt/gojay/tree/master/gojay) to make usage easier and faster. 
+
 # Why another JSON parser?
 
 I looked at other fast decoder/encoder and realised it was mostly hardly readable static code generation or a lot of reflection, poor streaming features, and not so fast in the end. 
@@ -31,7 +36,7 @@ go get github.com/francoispqt/gojay
 * [Encoder](#encoding)
 * [Decoder](#decoding)
 * [Stream API](#stream-api)
-
+* [Code Generation](https://github.com/francoispqt/gojay/tree/master/gojay)
 
 ## Decoding
 

decode.go

@@ -294,7 +294,13 @@ func (dec *Decoder) AddUint64(v *uint64) error {
 // AddFloat decodes the next key to a *float64.
 // If next key value overflows float64, an InvalidUnmarshalError error will be returned.
 func (dec *Decoder) AddFloat(v *float64) error {
-	return dec.Float(v)
+	return dec.Float64(v)
+}
+
+// AddFloat64 decodes the next key to a *float64.
+// If next key value overflows float64, an InvalidUnmarshalError error will be returned.
+func (dec *Decoder) AddFloat64(v *float64) error {
+	return dec.Float64(v)
 }
 
 // AddFloat32 decodes the next key to a *float64.
@@ -428,6 +434,12 @@ func (dec *Decoder) Uint64(v *uint64) error {
 // Float decodes the next key to a *float64.
 // If next key value overflows float64, an InvalidUnmarshalError error will be returned.
 func (dec *Decoder) Float(v *float64) error {
+	return dec.Float64(v)
+}
+
+// Float64 decodes the next key to a *float64.
+// If next key value overflows float64, an InvalidUnmarshalError error will be returned.
+func (dec *Decoder) Float64(v *float64) error {
 	err := dec.decodeFloat64(v)
 	if err != nil {
 		return err

decode_array.go

@@ -106,3 +106,23 @@ func (dec *Decoder) skipArray() (int, error) {
 	}
 	return 0, dec.raiseInvalidJSONErr(dec.cursor)
 }
+
+// DecodeArrayFunc is a custom func type implementing UnarshaleArray.
+// Use it to cast a func(*Decoder) to Unmarshal an object.
+//
+//	str := ""
+//	dec := gojay.NewDecoder(io.Reader)
+//	dec.DecodeArray(gojay.DecodeArrayFunc(func(dec *gojay.Decoder, k string) error {
+//		return dec.AddString(&str)
+//	}))
+type DecodeArrayFunc func(*Decoder) error
+
+// UnmarshalJSONArray implements UnarshalerArray.
+func (f DecodeArrayFunc) UnmarshalJSONArray(dec *Decoder) error {
+	return f(dec)
+}
+
+// IsNil implements UnarshalerArray.
+func (f DecodeArrayFunc) IsNil() bool {
+	return f == nil
+}

decode_array_test.go

@@ -566,3 +566,8 @@ func TestDecodeArrayNullError(t *testing.T) {
 	assert.NotNil(t, err, "err should not be nil")
 	assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError")
 }
+
+func TestDecoderArrayFunc(t *testing.T) {
+	var f DecodeArrayFunc
+	assert.True(t, f.IsNil())
+}

decode_number_float_test.go

@@ -630,3 +630,58 @@ func TestDecoderFloat32(t *testing.T) {
 		assert.IsType(t, InvalidJSONError(""), err, "err should be of type InvalidJSONError")
 	})
 }
+
+func TestDecoderFloat64Field(t *testing.T) {
+	var testCasesBasic = []struct {
+		name  string
+		json  string
+		value float64
+	}{
+		{
+			name:  "basic",
+			json:  "[1]",
+			value: float64(1),
+		},
+		{
+			name:  "big",
+			json:  "[0]",
+			value: float64(0),
+		},
+	}
+	for _, testCase := range testCasesBasic {
+		t.Run(testCase.name, func(t *testing.T) {
+			var dec = NewDecoder(strings.NewReader(testCase.json))
+			var v float64
+			dec.DecodeArray(DecodeArrayFunc(func(dec *Decoder) error {
+				return dec.AddFloat64(&v)
+			}))
+			assert.Equal(t, testCase.value, v)
+		})
+	}
+	var testCasesBasicAlt = []struct {
+		name  string
+		json  string
+		value float64
+	}{
+		{
+			name:  "basic",
+			json:  "[1]",
+			value: float64(1),
+		},
+		{
+			name:  "big",
+			json:  "[0]",
+			value: float64(0),
+		},
+	}
+	for _, testCase := range testCasesBasicAlt {
+		t.Run(testCase.name, func(t *testing.T) {
+			var dec = NewDecoder(strings.NewReader(testCase.json))
+			var v float64
+			dec.DecodeArray(DecodeArrayFunc(func(dec *Decoder) error {
+				return dec.Float(&v)
+			}))
+			assert.Equal(t, testCase.value, v)
+		})
+	}
+}

encode_array.go

@@ -128,3 +128,22 @@ func (enc *Encoder) ArrayKeyOmitEmpty(key string, v MarshalerJSONArray) {
 	v.MarshalJSONArray(enc)
 	enc.writeByte(']')
 }
+
+// EncodeArrayFunc is a custom func type implementing MarshaleArray.
+// Use it to cast a func(*Encoder) to Marshal an object.
+//
+//	enc := gojay.NewEncoder(io.Writer)
+//	enc.EncodeArray(gojay.EncodeArrayFunc(func(enc *gojay.Encoder) {
+//		enc.AddStringKey("hello", "world")
+//	}))
+type EncodeArrayFunc func(*Encoder)
+
+// MarshalJSONArray implements MarshalerJSONArray.
+func (f EncodeArrayFunc) MarshalJSONArray(enc *Encoder) {
+	f(enc)
+}
+
+// IsNil implements MarshalerJSONArray.
+func (f EncodeArrayFunc) IsNil() bool {
+	return f == nil
+}

encode_array_test.go

@@ -331,3 +331,8 @@ func TestEncoderArrErrors(t *testing.T) {
 		assert.True(t, false, "should not be called as it should have panicked")
 	})
 }
+
+func TestEncoderArrayFunc(t *testing.T) {
+	var f EncodeArrayFunc
+	assert.True(t, f.IsNil())
+}

encode_number_float.go

@@ -41,17 +41,61 @@ func (enc *Encoder) encodeFloat32(n float32) ([]byte, error) {
 
 // AddFloat adds a float64 to be encoded, must be used inside a slice or array encoding (does not encode a key)
 func (enc *Encoder) AddFloat(v float64) {
-	enc.Float(v)
+	enc.Float64(v)
 }
 
 // AddFloatOmitEmpty adds a float64 to be encoded and skips it if its value is 0,
 // must be used inside a slice or array encoding (does not encode a key).
 func (enc *Encoder) AddFloatOmitEmpty(v float64) {
-	enc.FloatOmitEmpty(v)
+	enc.Float64OmitEmpty(v)
 }
 
 // Float adds a float64 to be encoded, must be used inside a slice or array encoding (does not encode a key)
 func (enc *Encoder) Float(v float64) {
+	enc.Float64(v)
+}
+
+// FloatOmitEmpty adds a float64 to be encoded and skips it if its value is 0,
+// must be used inside a slice or array encoding (does not encode a key).
+func (enc *Encoder) FloatOmitEmpty(v float64) {
+	enc.Float64OmitEmpty(v)
+}
+
+// AddFloatKey adds a float64 to be encoded, must be used inside an object as it will encode a key
+func (enc *Encoder) AddFloatKey(key string, v float64) {
+	enc.Float64Key(key, v)
+}
+
+// AddFloatKeyOmitEmpty adds a float64 to be encoded and skips it if its value is 0.
+// Must be used inside an object as it will encode a key
+func (enc *Encoder) AddFloatKeyOmitEmpty(key string, v float64) {
+	enc.Float64KeyOmitEmpty(key, v)
+}
+
+// FloatKey adds a float64 to be encoded, must be used inside an object as it will encode a key
+func (enc *Encoder) FloatKey(key string, v float64) {
+	enc.Float64Key(key, v)
+}
+
+// FloatKeyOmitEmpty adds a float64 to be encoded and skips it if its value is 0.
+// Must be used inside an object as it will encode a key
+func (enc *Encoder) FloatKeyOmitEmpty(key string, v float64) {
+	enc.Float64KeyOmitEmpty(key, v)
+}
+
+// AddFloat64 adds a float64 to be encoded, must be used inside a slice or array encoding (does not encode a key)
+func (enc *Encoder) AddFloat64(v float64) {
+	enc.Float(v)
+}
+
+// AddFloat64OmitEmpty adds a float64 to be encoded and skips it if its value is 0,
+// must be used inside a slice or array encoding (does not encode a key).
+func (enc *Encoder) AddFloat64OmitEmpty(v float64) {
+	enc.FloatOmitEmpty(v)
+}
+
+// Float64 adds a float64 to be encoded, must be used inside a slice or array encoding (does not encode a key)
+func (enc *Encoder) Float64(v float64) {
 	enc.grow(10)
 	r := enc.getPreviousRune()
 	if r != '[' {
@@ -60,9 +104,9 @@ func (enc *Encoder) Float(v float64) {
 	enc.buf = strconv.AppendFloat(enc.buf, v, 'f', -1, 64)
 }
 
-// FloatOmitEmpty adds a float64 to be encoded and skips it if its value is 0,
+// Float64OmitEmpty adds a float64 to be encoded and skips it if its value is 0,
 // must be used inside a slice or array encoding (does not encode a key).
-func (enc *Encoder) FloatOmitEmpty(v float64) {
+func (enc *Encoder) Float64OmitEmpty(v float64) {
 	if v == 0 {
 		return
 	}
@@ -74,19 +118,19 @@ func (enc *Encoder) FloatOmitEmpty(v float64) {
 	enc.buf = strconv.AppendFloat(enc.buf, v, 'f', -1, 64)
 }
 
-// AddFloatKey adds a float64 to be encoded, must be used inside an object as it will encode a key
-func (enc *Encoder) AddFloatKey(key string, v float64) {
+// AddFloat64Key adds a float64 to be encoded, must be used inside an object as it will encode a key
+func (enc *Encoder) AddFloat64Key(key string, v float64) {
 	enc.FloatKey(key, v)
 }
 
-// AddFloatKeyOmitEmpty adds a float64 to be encoded and skips it if its value is 0.
+// AddFloat64KeyOmitEmpty adds a float64 to be encoded and skips it if its value is 0.
 // Must be used inside an object as it will encode a key
-func (enc *Encoder) AddFloatKeyOmitEmpty(key string, v float64) {
+func (enc *Encoder) AddFloat64KeyOmitEmpty(key string, v float64) {
 	enc.FloatKeyOmitEmpty(key, v)
 }
 
-// FloatKey adds a float64 to be encoded, must be used inside an object as it will encode a key
-func (enc *Encoder) FloatKey(key string, value float64) {
+// Float64Key adds a float64 to be encoded, must be used inside an object as it will encode a key
+func (enc *Encoder) Float64Key(key string, value float64) {
 	r := enc.getPreviousRune()
 	if r != '{' {
 		enc.writeByte(',')
@@ -98,9 +142,9 @@ func (enc *Encoder) FloatKey(key string, value float64) {
 	enc.buf = strconv.AppendFloat(enc.buf, value, 'f', -1, 64)
 }
 
-// FloatKeyOmitEmpty adds a float64 to be encoded and skips it if its value is 0.
+// Float64KeyOmitEmpty adds a float64 to be encoded and skips it if its value is 0.
 // Must be used inside an object as it will encode a key
-func (enc *Encoder) FloatKeyOmitEmpty(key string, v float64) {
+func (enc *Encoder) Float64KeyOmitEmpty(key string, v float64) {
 	if v == 0 {
 		return
 	}