Merge pull request #234 from tendermint/develop

Release v0.13.0

Author: liamsi

CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.13.0 (October 15, 2018)
+
+BREAKING CHANGE:
+ - `time.Time`: validate seconds since 1970 are in valid range during encoding; i.e. in the interval [-62135596800, 253402300800)
+ - `time.Time`: match encoding of time.Time to protobuf's well known type [Timestamp] ([#224])
+ - Rename `MarshalBinary` to `MarshalBinaryLengthPrefixed` ([#222])
+ 
+[Timestamp]: https://github.com/protocolbuffers/protobuf/blob/d2980062c859649523d5fd51d6b55ab310e47482/src/google/protobuf/timestamp.proto#L123-L135
+
+IMPROVEMENTS:
+  - Add `MustUnmarshalJSON` and `MustMarshalJSON` that panic if an error occurs ([#228])
+  - Optimize performance by removing `defer`s in `getTypeInfo` ([#227] by @ValarDragon) 
+  - Optimize performance by removing unnecessary allocation in `UvarintSize` ([#225] by [@ValarDragon])
+  - Add test that shows compatibility with stdlib (JSON time encoding) ([#131] by [@odeke-em]) 
+  
+[#224]: https://github.com/tendermint/go-amino/pull/224
+[#222]: https://github.com/tendermint/go-amino/pull/222
+[#228]: https://github.com/tendermint/go-amino/pull/228
+[#227]: https://github.com/tendermint/go-amino/pull/227
+[#225]: https://github.com/tendermint/go-amino/pull/225
+[#131]: https://github.com/tendermint/go-amino/pull/131
+[@ValarDragon]: https://github.com/ValarDragon
+[@odeke-em]: https://github.com/odeke-em
+
 ## 0.12.0 (August 4, 2018)
 
 BREAKING CHANGE:

amino.go

@@ -32,16 +32,16 @@ func init() {
 	}
 }
 
-func MarshalBinary(o interface{}) ([]byte, error) {
-	return gcdc.MarshalBinary(o)
+func MarshalBinaryLengthPrefixed(o interface{}) ([]byte, error) {
+	return gcdc.MarshalBinaryLengthPrefixed(o)
 }
 
-func MarshalBinaryWriter(w io.Writer, o interface{}) (n int64, err error) {
-	return gcdc.MarshalBinaryWriter(w, o)
+func MarshalBinaryLengthPrefixedWriter(w io.Writer, o interface{}) (n int64, err error) {
+	return gcdc.MarshalBinaryLengthPrefixedWriter(w, o)
 }
 
-func MustMarshalBinary(o interface{}) []byte {
-	return gcdc.MustMarshalBinary(o)
+func MustMarshalBinaryLengthPrefixed(o interface{}) []byte {
+	return gcdc.MustMarshalBinaryLengthPrefixed(o)
 }
 
 func MarshalBinaryBare(o interface{}) ([]byte, error) {
@@ -52,16 +52,16 @@ func MustMarshalBinaryBare(o interface{}) []byte {
 	return gcdc.MustMarshalBinaryBare(o)
 }
 
-func UnmarshalBinary(bz []byte, ptr interface{}) error {
-	return gcdc.UnmarshalBinary(bz, ptr)
+func UnmarshalBinaryLengthPrefixed(bz []byte, ptr interface{}) error {
+	return gcdc.UnmarshalBinaryLengthPrefixedBinary(bz, ptr)
 }
 
-func UnmarshalBinaryReader(r io.Reader, ptr interface{}, maxSize int64) (n int64, err error) {
-	return gcdc.UnmarshalBinaryReader(r, ptr, maxSize)
+func UnmarshalBinaryLengthPrefixedReader(r io.Reader, ptr interface{}, maxSize int64) (n int64, err error) {
+	return gcdc.UnmarshalBinaryLengthPrefixedReader(r, ptr, maxSize)
 }
 
-func MustUnmarshalBinary(bz []byte, ptr interface{}) {
-	gcdc.MustUnmarshalBinary(bz, ptr)
+func MustUnmarshalBinaryLengthPrefixed(bz []byte, ptr interface{}) {
+	gcdc.MustUnmarshalBinaryLengthPrefixed(bz, ptr)
 }
 
 func UnmarshalBinaryBare(bz []byte, ptr interface{}) error {
@@ -127,14 +127,14 @@ func (typ Typ3) String() string {
 //----------------------------------------
 // *Codec methods
 
-// MarshalBinary encodes the object o according to the Amino spec,
+// MarshalBinaryLengthPrefixed encodes the object o according to the Amino spec,
 // but prefixed by a uvarint encoding of the object to encode.
 // Use MarshalBinaryBare if you don't want byte-length prefixing.
 //
-// For consistency, MarshalBinary will first dereference pointers
-// before encoding.  MarshalBinary will panic if o is a nil-pointer,
+// For consistency, MarshalBinaryLengthPrefixed will first dereference pointers
+// before encoding.  MarshalBinaryLengthPrefixed will panic if o is a nil-pointer,
 // or if o is invalid.
-func (cdc *Codec) MarshalBinary(o interface{}) ([]byte, error) {
+func (cdc *Codec) MarshalBinaryLengthPrefixed(o interface{}) ([]byte, error) {
 
 	// Write the bytes here.
 	var buf = new(bytes.Buffer)
@@ -160,11 +160,11 @@ func (cdc *Codec) MarshalBinary(o interface{}) ([]byte, error) {
 	return buf.Bytes(), nil
 }
 
-// MarshalBinaryWriter writes the bytes as would be returned from
-// MarshalBinary to the writer w.
-func (cdc *Codec) MarshalBinaryWriter(w io.Writer, o interface{}) (n int64, err error) {
+// MarshalBinaryLengthPrefixedWriter writes the bytes as would be returned from
+// MarshalBinaryLengthPrefixed to the writer w.
+func (cdc *Codec) MarshalBinaryLengthPrefixedWriter(w io.Writer, o interface{}) (n int64, err error) {
 	var bz, _n = []byte(nil), int(0)
-	bz, err = cdc.MarshalBinary(o)
+	bz, err = cdc.MarshalBinaryLengthPrefixed(o)
 	if err != nil {
 		return 0, err
 	}
@@ -174,8 +174,8 @@ func (cdc *Codec) MarshalBinaryWriter(w io.Writer, o interface{}) (n int64, err
 }
 
 // Panics if error.
-func (cdc *Codec) MustMarshalBinary(o interface{}) []byte {
-	bz, err := cdc.MarshalBinary(o)
+func (cdc *Codec) MustMarshalBinaryLengthPrefixed(o interface{}) []byte {
+	bz, err := cdc.MarshalBinaryLengthPrefixed(o)
 	if err != nil {
 		panic(err)
 	}
@@ -191,8 +191,8 @@ func (cdc *Codec) MarshalBinaryBare(o interface{}) ([]byte, error) {
 	var rv, _, isNilPtr = derefPointers(reflect.ValueOf(o))
 	if isNilPtr {
 		// NOTE: You can still do so by calling
-		// `.MarshalBinary(struct{ *SomeType })` or so on.
-		panic("MarshalBinary cannot marshal a nil pointer directly. Try wrapping in a struct?")
+		// `.MarshalBinaryLengthPrefixed(struct{ *SomeType })` or so on.
+		panic("MarshalBinaryBare cannot marshal a nil pointer directly. Try wrapping in a struct?")
 	}
 
 	// Encode Amino:binary bytes.
@@ -228,11 +228,11 @@ func (cdc *Codec) MustMarshalBinaryBare(o interface{}) []byte {
 }
 
 // Like UnmarshalBinaryBare, but will first decode the byte-length prefix.
-// UnmarshalBinary will panic if ptr is a nil-pointer.
+// UnmarshalBinaryLengthPrefixedBinary will panic if ptr is a nil-pointer.
 // Returns an error if not all of bz is consumed.
-func (cdc *Codec) UnmarshalBinary(bz []byte, ptr interface{}) error {
+func (cdc *Codec) UnmarshalBinaryLengthPrefixedBinary(bz []byte, ptr interface{}) error {
 	if len(bz) == 0 {
-		return errors.New("UnmarshalBinary cannot decode empty bytes")
+		return errors.New("UnmarshalBinaryLengthPrefixedBinary cannot decode empty bytes")
 	}
 
 	// Read byte-length prefix.
@@ -241,10 +241,10 @@ func (cdc *Codec) UnmarshalBinary(bz []byte, ptr interface{}) error {
 		return fmt.Errorf("Error reading msg byte-length prefix: got code %v", n)
 	}
 	if u64 > uint64(len(bz)-n) {
-		return fmt.Errorf("Not enough bytes to read in UnmarshalBinary, want %v more bytes but only have %v",
+		return fmt.Errorf("Not enough bytes to read in UnmarshalBinaryLengthPrefixedBinary, want %v more bytes but only have %v",
 			u64, len(bz)-n)
 	} else if u64 < uint64(len(bz)-n) {
-		return fmt.Errorf("Bytes left over in UnmarshalBinary, should read %v more bytes but have %v",
+		return fmt.Errorf("Bytes left over in UnmarshalBinaryLengthPrefixedBinary, should read %v more bytes but have %v",
 			u64, len(bz)-n)
 	}
 	bz = bz[n:]
@@ -254,9 +254,9 @@ func (cdc *Codec) UnmarshalBinary(bz []byte, ptr interface{}) error {
 }
 
 // Like UnmarshalBinaryBare, but will first read the byte-length prefix.
-// UnmarshalBinaryReader will panic if ptr is a nil-pointer.
+// UnmarshalBinaryLengthPrefixedReader will panic if ptr is a nil-pointer.
 // If maxSize is 0, there is no limit (not recommended).
-func (cdc *Codec) UnmarshalBinaryReader(r io.Reader, ptr interface{}, maxSize int64) (n int64, err error) {
+func (cdc *Codec) UnmarshalBinaryLengthPrefixedReader(r io.Reader, ptr interface{}, maxSize int64) (n int64, err error) {
 	if maxSize < 0 {
 		panic("maxSize cannot be negative.")
 	}
@@ -310,8 +310,8 @@ func (cdc *Codec) UnmarshalBinaryReader(r io.Reader, ptr interface{}, maxSize in
 }
 
 // Panics if error.
-func (cdc *Codec) MustUnmarshalBinary(bz []byte, ptr interface{}) {
-	err := cdc.UnmarshalBinary(bz, ptr)
+func (cdc *Codec) MustUnmarshalBinaryLengthPrefixed(bz []byte, ptr interface{}) {
+	err := cdc.UnmarshalBinaryLengthPrefixedBinary(bz, ptr)
 	if err != nil {
 		panic(err)
 	}
@@ -399,6 +399,15 @@ func (cdc *Codec) MarshalJSON(o interface{}) ([]byte, error) {
 	return w.Bytes(), nil
 }
 
+// MustMarshalJSON panics if an error occurs. Besides tha behaves exactly like MarshalJSON.
+func (cdc *Codec) MustMarshalJSON(o interface{}) []byte {
+	bz, err := cdc.MarshalJSON(o)
+	if err != nil {
+		panic(err)
+	}
+	return bz
+}
+
 func (cdc *Codec) UnmarshalJSON(bz []byte, ptr interface{}) error {
 	if len(bz) == 0 {
 		return errors.New("UnmarshalJSON cannot decode empty bytes")
@@ -430,6 +439,13 @@ func (cdc *Codec) UnmarshalJSON(bz []byte, ptr interface{}) error {
 	return cdc.decodeReflectJSON(bz, info, rv, FieldOptions{})
 }
 
+// MustUnmarshalJSON panics if an error occurs. Besides tha behaves exactly like UnmarshalJSON.
+func (cdc *Codec) MustUnmarshalJSON(bz []byte, ptr interface{}) {
+	if err := cdc.UnmarshalJSON(bz, ptr); err != nil {
+		panic(err)
+	}
+}
+
 // MarshalJSONIndent calls json.Indent on the output of cdc.MarshalJSON
 // using the given prefix and indent string.
 func (cdc *Codec) MarshalJSONIndent(o interface{}, prefix, indent string) ([]byte, error) {

amino_test.go

@@ -24,12 +24,12 @@ func TestMarshalBinary(t *testing.T) {
 		Time:   time.Now().UTC().Truncate(time.Millisecond), // strip monotonic and timezone.
 	}
 
-	b, err := cdc.MarshalBinary(s)
+	b, err := cdc.MarshalBinaryLengthPrefixed(s)
 	assert.Nil(t, err)
-	t.Logf("MarshalBinary(s) -> %X", b)
+	t.Logf("MarshalBinaryLengthPrefixed(s) -> %X", b)
 
 	var s2 SimpleStruct
-	err = cdc.UnmarshalBinary(b, &s2)
+	err = cdc.UnmarshalBinaryLengthPrefixedBinary(b, &s2)
 	assert.Nil(t, err)
 	assert.Equal(t, s, s2)
 }
@@ -49,12 +49,12 @@ func TestUnmarshalBinaryReader(t *testing.T) {
 		Time:   time.Now().UTC().Truncate(time.Millisecond), // strip monotonic and timezone.
 	}
 
-	b, err := cdc.MarshalBinary(s)
+	b, err := cdc.MarshalBinaryLengthPrefixed(s)
 	assert.Nil(t, err)
-	t.Logf("MarshalBinary(s) -> %X", b)
+	t.Logf("MarshalBinaryLengthPrefixed(s) -> %X", b)
 
 	var s2 SimpleStruct
-	_, err = cdc.UnmarshalBinaryReader(bytes.NewBuffer(b), &s2, 0)
+	_, err = cdc.UnmarshalBinaryLengthPrefixedReader(bytes.NewBuffer(b), &s2, 0)
 	assert.Nil(t, err)
 
 	assert.Equal(t, s, s2)
@@ -64,13 +64,13 @@ func TestUnmarshalBinaryReaderSize(t *testing.T) {
 	var cdc = amino.NewCodec()
 
 	var s1 string = "foo"
-	b, err := cdc.MarshalBinary(s1)
+	b, err := cdc.MarshalBinaryLengthPrefixed(s1)
 	assert.Nil(t, err)
-	t.Logf("MarshalBinary(s) -> %X", b)
+	t.Logf("MarshalBinaryLengthPrefixed(s) -> %X", b)
 
 	var s2 string
 	var n int64
-	n, err = cdc.UnmarshalBinaryReader(bytes.NewBuffer(b), &s2, 0)
+	n, err = cdc.UnmarshalBinaryLengthPrefixedReader(bytes.NewBuffer(b), &s2, 0)
 	assert.Nil(t, err)
 	assert.Equal(t, s1, s2)
 	frameLengthBytes, msgLengthBytes := 1, 1
@@ -81,15 +81,15 @@ func TestUnmarshalBinaryReaderSizeLimit(t *testing.T) {
 	var cdc = amino.NewCodec()
 
 	var s1 string = "foo"
-	b, err := cdc.MarshalBinary(s1)
+	b, err := cdc.MarshalBinaryLengthPrefixed(s1)
 	assert.Nil(t, err)
-	t.Logf("MarshalBinary(s) -> %X", b)
+	t.Logf("MarshalBinaryLengthPrefixed(s) -> %X", b)
 
 	var s2 string
 	var n int64
-	n, err = cdc.UnmarshalBinaryReader(bytes.NewBuffer(b), &s2, int64(len(b)-1))
+	n, err = cdc.UnmarshalBinaryLengthPrefixedReader(bytes.NewBuffer(b), &s2, int64(len(b)-1))
 	assert.NotNil(t, err, "insufficient limit should lead to failure")
-	n, err = cdc.UnmarshalBinaryReader(bytes.NewBuffer(b), &s2, int64(len(b)))
+	n, err = cdc.UnmarshalBinaryLengthPrefixedReader(bytes.NewBuffer(b), &s2, int64(len(b)))
 	assert.Nil(t, err, "sufficient limit should not cause failure")
 	assert.Equal(t, s1, s2)
 	frameLengthBytes, msgLengthBytes := 1, 1
@@ -111,12 +111,12 @@ func TestUnmarshalBinaryReaderTooLong(t *testing.T) {
 		Time:   time.Now().UTC().Truncate(time.Millisecond), // strip monotonic and timezone.
 	}
 
-	b, err := cdc.MarshalBinary(s)
+	b, err := cdc.MarshalBinaryLengthPrefixed(s)
 	assert.Nil(t, err)
-	t.Logf("MarshalBinary(s) -> %X", b)
+	t.Logf("MarshalBinaryLengthPrefixed(s) -> %X", b)
 
 	var s2 SimpleStruct
-	_, err = cdc.UnmarshalBinaryReader(bytes.NewBuffer(b), &s2, 1) // 1 byte limit is ridiculous.
+	_, err = cdc.UnmarshalBinaryLengthPrefixedReader(bytes.NewBuffer(b), &s2, 1) // 1 byte limit is ridiculous.
 	assert.NotNil(t, err)
 }
 
@@ -126,26 +126,26 @@ func TestUnmarshalBinaryBufferedWritesReads(t *testing.T) {
 
 	// Write 3 times.
 	var s1 string = "foo"
-	_, err := cdc.MarshalBinaryWriter(buf, s1)
+	_, err := cdc.MarshalBinaryLengthPrefixedWriter(buf, s1)
 	assert.Nil(t, err)
-	_, err = cdc.MarshalBinaryWriter(buf, s1)
+	_, err = cdc.MarshalBinaryLengthPrefixedWriter(buf, s1)
 	assert.Nil(t, err)
-	_, err = cdc.MarshalBinaryWriter(buf, s1)
+	_, err = cdc.MarshalBinaryLengthPrefixedWriter(buf, s1)
 	assert.Nil(t, err)
 
 	// Read 3 times.
 	var s2 string
-	_, err = cdc.UnmarshalBinaryReader(buf, &s2, 0)
+	_, err = cdc.UnmarshalBinaryLengthPrefixedReader(buf, &s2, 0)
 	assert.Nil(t, err)
 	assert.Equal(t, s1, s2)
-	_, err = cdc.UnmarshalBinaryReader(buf, &s2, 0)
+	_, err = cdc.UnmarshalBinaryLengthPrefixedReader(buf, &s2, 0)
 	assert.Nil(t, err)
 	assert.Equal(t, s1, s2)
-	_, err = cdc.UnmarshalBinaryReader(buf, &s2, 0)
+	_, err = cdc.UnmarshalBinaryLengthPrefixedReader(buf, &s2, 0)
 	assert.Nil(t, err)
 	assert.Equal(t, s1, s2)
 
 	// Reading 4th time fails.
-	_, err = cdc.UnmarshalBinaryReader(buf, &s2, 0)
+	_, err = cdc.UnmarshalBinaryLengthPrefixedReader(buf, &s2, 0)
 	assert.NotNil(t, err)
 }

binary-decode.go

@@ -6,7 +6,6 @@ import (
 	"reflect"
 	"time"
 
-	"encoding/binary"
 	"github.com/davecgh/go-spew/spew"
 )
 
@@ -838,33 +837,6 @@ func consumeAny(typ3 Typ3, bz []byte) (n int, err error) {
 	return
 }
 
-func consumeStruct(bz []byte) (n int, err error) {
-	var _n, typ = int(0), Typ3(0x00)
-	for {
-		typ, _n, err = consumeFieldKey(bz)
-		if slide(&bz, &n, _n) && err != nil {
-			return
-		}
-		_n, err = consumeAny(typ, bz)
-		if slide(&bz, &n, _n) && err != nil {
-			return
-		}
-	}
-	return
-}
-
-func consumeFieldKey(bz []byte) (typ Typ3, n int, err error) {
-	var u64 uint64
-	u64, n = binary.Uvarint(bz)
-	if n < 0 {
-		n = 0
-		err = errors.New("error decoding uvarint")
-		return
-	}
-	typ = Typ3(u64 & 0x07)
-	return
-}
-
 //----------------------------------------
 
 func DecodeDisambPrefixBytes(bz []byte) (db DisambBytes, hasDb bool, pb PrefixBytes, hasPb bool, n int, err error) {