refactor(*) fix for golint, etc.

basic.go

@@ -98,14 +98,14 @@ func (e *basicEncoderImpl) encodeBasic(input interface{}, signals []*PrimitivePa
 		}
 		root.AddPrimitivePacket(primitiveEncoder)
 		return root.Encode(), nil
-	} else {
-		buf := make([][]byte, 0)
-		for _, signal := range signals {
-			buf = append(buf, signal.Encode())
-		}
-		buf = append(buf, primitiveEncoder.Encode())
-		return bytes.Join(buf, []byte{}), nil
 	}
+
+	buf := make([][]byte, 0)
+	for _, signal := range signals {
+		buf = append(buf, signal.Encode())
+	}
+	buf = append(buf, primitiveEncoder.Encode())
+	return bytes.Join(buf, []byte{}), nil
 }
 
 // encodeBasicSlice encode reflect.Value of slice, and inserting signals
@@ -148,14 +148,14 @@ func (e *basicEncoderImpl) encodeBasicSlice(value reflect.Value, signals []*Prim
 		}
 		root.AddNodePacket(nodeEncoder)
 		return root.Encode(), nil
-	} else {
-		buf := make([][]byte, 0)
-		for _, signal := range signals {
-			buf = append(buf, signal.Encode())
-		}
-		buf = append(buf, nodeEncoder.Encode())
-		return bytes.Join(buf, []byte{}), nil
 	}
+
+	buf := make([][]byte, 0)
+	for _, signal := range signals {
+		buf = append(buf, signal.Encode())
+	}
+	buf = append(buf, nodeEncoder.Encode())
+	return bytes.Join(buf, []byte{}), nil
 }
 
 // encodeBasicString encode string to PrimitivePacketEncoder
@@ -216,7 +216,7 @@ func (e *basicEncoderImpl) encodeBasicBool(input interface{}) *PrimitivePacketEn
 
 // encodeBasicStringSlice encode reflect.Value of []string to NodePacketEncoder
 func (e *basicEncoderImpl) encodeBasicStringSlice(value reflect.Value) *NodePacketEncoder {
-	var node = NewNodeArrayPacketEncoder(int(e.observe))
+	var node = NewNodeSlicePacketEncoder(int(e.observe))
 	if out, ok := utils.ToStringSliceArray(value.Interface()); ok {
 		for _, v := range out {
 			var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem)
@@ -229,7 +229,7 @@ func (e *basicEncoderImpl) encodeBasicStringSlice(value reflect.Value) *NodePack
 
 // encodeBasicInt32Slice encode reflect.Value of []int32 to NodePacketEncoder
 func (e *basicEncoderImpl) encodeBasicInt32Slice(value reflect.Value) *NodePacketEncoder {
-	var node = NewNodeArrayPacketEncoder(int(e.observe))
+	var node = NewNodeSlicePacketEncoder(int(e.observe))
 	if out, ok := utils.ToInt64SliceArray(value.Interface()); ok {
 		for _, v := range out {
 			var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem)
@@ -242,7 +242,7 @@ func (e *basicEncoderImpl) encodeBasicInt32Slice(value reflect.Value) *NodePacke
 
 // encodeBasicUint32Slice encode reflect.Value of []uint32 to NodePacketEncoder
 func (e *basicEncoderImpl) encodeBasicUint32Slice(value reflect.Value) *NodePacketEncoder {
-	var node = NewNodeArrayPacketEncoder(int(e.observe))
+	var node = NewNodeSlicePacketEncoder(int(e.observe))
 	if out, ok := utils.ToUInt64SliceArray(value.Interface()); ok {
 		for _, v := range out {
 			var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem)
@@ -255,7 +255,7 @@ func (e *basicEncoderImpl) encodeBasicUint32Slice(value reflect.Value) *NodePack
 
 // encodeBasicInt64Slice encode reflect.Value of []int64 to NodePacketEncoder
 func (e *basicEncoderImpl) encodeBasicInt64Slice(value reflect.Value) *NodePacketEncoder {
-	var node = NewNodeArrayPacketEncoder(int(e.observe))
+	var node = NewNodeSlicePacketEncoder(int(e.observe))
 	if out, ok := utils.ToInt64SliceArray(value.Interface()); ok {
 		for _, v := range out {
 			var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem)
@@ -268,7 +268,7 @@ func (e *basicEncoderImpl) encodeBasicInt64Slice(value reflect.Value) *NodePacke
 
 // encodeBasicUint64Slice encode reflect.Value of []uint64 to NodePacketEncoder
 func (e *basicEncoderImpl) encodeBasicUint64Slice(value reflect.Value) *NodePacketEncoder {
-	var node = NewNodeArrayPacketEncoder(int(e.observe))
+	var node = NewNodeSlicePacketEncoder(int(e.observe))
 	if out, ok := utils.ToUInt64SliceArray(value.Interface()); ok {
 		for _, v := range out {
 			var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem)
@@ -281,7 +281,7 @@ func (e *basicEncoderImpl) encodeBasicUint64Slice(value reflect.Value) *NodePack
 
 // encodeBasicFloat32Slice encode reflect.Value of []float32 to NodePacketEncoder
 func (e *basicEncoderImpl) encodeBasicFloat32Slice(value reflect.Value) *NodePacketEncoder {
-	var node = NewNodeArrayPacketEncoder(int(e.observe))
+	var node = NewNodeSlicePacketEncoder(int(e.observe))
 	if out, ok := utils.ToUFloat64SliceArray(value.Interface()); ok {
 		for _, v := range out {
 			var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem)
@@ -294,7 +294,7 @@ func (e *basicEncoderImpl) encodeBasicFloat32Slice(value reflect.Value) *NodePac
 
 // encodeBasicFloat64Slice encode reflect.Value of []float64 to NodePacketEncoder
 func (e *basicEncoderImpl) encodeBasicFloat64Slice(value reflect.Value) *NodePacketEncoder {
-	var node = NewNodeArrayPacketEncoder(int(e.observe))
+	var node = NewNodeSlicePacketEncoder(int(e.observe))
 	if out, ok := utils.ToUFloat64SliceArray(value.Interface()); ok {
 		for _, v := range out {
 			var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem)
@@ -307,7 +307,7 @@ func (e *basicEncoderImpl) encodeBasicFloat64Slice(value reflect.Value) *NodePac
 
 // encodeBasicBoolSlice encode reflect.Value of []bool to NodePacketEncoder
 func (e *basicEncoderImpl) encodeBasicBoolSlice(value reflect.Value) *NodePacketEncoder {
-	var node = NewNodeArrayPacketEncoder(int(e.observe))
+	var node = NewNodeSlicePacketEncoder(int(e.observe))
 	if out, ok := utils.ToBoolSliceArray(value.Interface()); ok {
 		for _, v := range out {
 			var item = NewPrimitivePacketEncoder(utils.KeyOfSliceItem)

codec.go

@@ -4,20 +4,20 @@ import (
 	"reflect"
 )
 
-// Y3Codec encode the user's data according to the Y3 encoding rules
-type Y3Codec interface {
+// Codec encode the user's data according to the Y3 encoding rules
+type Codec interface {
 	// Marshal encode interface to []byte
 	Marshal(input interface{}) ([]byte, error)
 }
 
-// NewCodec create a Y3Codec interface
-func NewCodec(observe byte) Y3Codec {
+// NewCodec create a Codec interface
+func NewCodec(observe byte) Codec {
 	return &y3Codec{
 		observe: observe,
 	}
 }
 
-// y3Codec is implementation of the Y3Codec interface
+// y3Codec is implementation of the Codec interface
 type y3Codec struct {
 	observe byte
 }

encoder.go

@@ -135,6 +135,7 @@ func (enc *PrimitivePacketEncoder) SetStringValue(v string) {
 	enc.valbuf = []byte(v)
 }
 
+// SetBytes set bytes to internal buf variable
 func (enc *PrimitivePacketEncoder) SetBytes(buf []byte) {
 	enc.valbuf = buf
 }
@@ -157,7 +158,8 @@ func NewNodePacketEncoder(sid int) *NodePacketEncoder {
 	return nodeEnc
 }
 
-func NewNodeArrayPacketEncoder(sid int) *NodePacketEncoder {
+// NewNodeSlicePacketEncoder returns an Encoder for node packet that is a slice
+func NewNodeSlicePacketEncoder(sid int) *NodePacketEncoder {
 	nodeEnc := &NodePacketEncoder{
 		encoder: encoder{
 			isNode:  true,

examples/packet/decode.go

@@ -102,7 +102,7 @@ func encodeArrayPacket() {
 	var club = y3.NewNodePacketEncoder(0x01)
 
 	// 0xc2 - []*bar
-	var bars = y3.NewNodeArrayPacketEncoder(0x02)
+	var bars = y3.NewNodeSlicePacketEncoder(0x02)
 
 	// 0x03 - Name="a1"
 	var bar1 = y3.NewNodePacketEncoder(0x00)
@@ -119,7 +119,7 @@ func encodeArrayPacket() {
 	bars.AddNodePacket(bar2)
 
 	// 0x44 - kinds
-	var kinds = y3.NewNodeArrayPacketEncoder(0x04)
+	var kinds = y3.NewNodeSlicePacketEncoder(0x04)
 
 	// 0x44 - item1
 	var item1 = y3.NewPrimitivePacketEncoder(0x00)

observable.go

@@ -7,10 +7,12 @@ import (
 	"github.com/yomorun/y3-codec-golang/pkg/encoding"
 )
 
+// Iterable iterate through and get the data of observe
 type Iterable interface {
 	Observe() <-chan interface{}
 }
 
+// Observable provide subscription and notification processing
 type Observable interface {
 	Iterable
 	Subscribe(key byte) Observable

observable_test.go

@@ -20,22 +20,18 @@ func TestObservable(t *testing.T) {
 		if (v[0] == 17) && (v[1] == 2) && (v[2] == 67) && (v[3] == 228) {
 			count1++
 			return "ok1", nil
-		} else {
-			err1 = errors.New("fail")
-			return nil, errors.New("fail")
 		}
-
+		err1 = errors.New("fail")
+		return nil, errors.New("fail")
 	}
 
 	callback2 := func(v []byte) (interface{}, error) {
 		if (v[0] == 19) && (v[1] == 2) && (v[2] == 65) && (v[3] == 240) {
 			count2++
 			return "ok2", nil
-		} else {
-			err2 = errors.New("fail")
-			return nil, errors.New("fail")
 		}
-
+		err2 = errors.New("fail")
+		return nil, errors.New("fail")
 	}
 
 	reader := bytes.NewReader(buf)

structure_decoder.go

@@ -128,8 +128,9 @@ func (d *structDecoderImpl) decodeSlice(data *NodePacket, val reflect.Value) err
 	elemType := val.Type().Elem()
 
 	items := make([]reflect.Value, 0)
-	for _, node := range data.NodePackets {
+	for i := range data.NodePackets {
 		elemValue := reflect.Indirect(reflect.New(elemType))
+		node := data.NodePackets[i]
 		err := d.decodeStruct(&node, elemValue)
 		if err != nil {
 			return err
@@ -408,11 +409,11 @@ func (d *structDecoderImpl) matchingKey(key byte, node *NodePacket) (flag bool,
 	}
 
 	if len(node.NodePackets) > 0 {
-		for _, n := range node.NodePackets {
+		for i := range node.NodePackets {
+			n := node.NodePackets[i]
 			if key == n.SeqID() {
 				return true, true, n
 			}
-			//return matchingKey(key, &n)
 			flag, isNode, packet = d.matchingKey(key, &n)
 			if flag {
 				return

structure_decoder_test.go

@@ -32,7 +32,10 @@ func TestBasic_Struct(t *testing.T) {
 }
 
 func runDecode(t *testing.T, inputBuf []byte, output interface{}) {
-	_, err := newStructDecoder(output).Decode(inputBuf)
+	_, err := newStructDecoder(output, structDecoderOptionConfig(&structDecoderConfig{
+		ZeroFields: true,
+		TagName:    "yomo",
+	})).Decode(inputBuf)
 	if err != nil {
 		t.Errorf("got an err: %s", err.Error())
 		t.FailNow()

structure_encoder.go

@@ -110,14 +110,14 @@ func (e *structEncoderImpl) encode(input interface{}, signals []*PrimitivePacket
 		}
 		root.AddNodePacket(nodeEncoder)
 		return root.Encode(), nil
-	} else {
-		buf := make([][]byte, 0)
-		for _, signal := range signals {
-			buf = append(buf, signal.Encode())
-		}
-		buf = append(buf, nodeEncoder.Encode())
-		return bytes.Join(buf, []byte{}), nil
 	}
+
+	buf := make([][]byte, 0)
+	for _, signal := range signals {
+		buf = append(buf, signal.Encode())
+	}
+	buf = append(buf, nodeEncoder.Encode())
+	return bytes.Join(buf, []byte{}), nil
 }
 
 // encodeSlice encode slice to NodePacketEncoder
@@ -199,12 +199,12 @@ func (e *structEncoderImpl) encodeStructFromField(fieldType reflect.Type, fieldN
 	case reflect.Bool:
 		ppe.SetBoolValue(e.fieldValueToBool(fieldType, fieldValue))
 	case reflect.Array:
-		arrNode := NewNodeArrayPacketEncoder(int(utils.KeyOf(fieldName)))
+		arrNode := NewNodeSlicePacketEncoder(int(utils.KeyOf(fieldName)))
 		e.encodeArrayFromField(fieldValue, arrNode)
 		en.AddNodePacket(arrNode)
 		return
 	case reflect.Slice:
-		sliceNode := NewNodeArrayPacketEncoder(int(utils.KeyOf(fieldName)))
+		sliceNode := NewNodeSlicePacketEncoder(int(utils.KeyOf(fieldName)))
 		e.encodeSliceFromField(fieldValue, sliceNode)
 		en.AddNodePacket(sliceNode)
 		return

structure_encoder_test.go

@@ -16,7 +16,11 @@ func TestStructEncoderWithSignals(t *testing.T) {
 		Therm: thermometer{Temperature: float32(30), Humidity: float32(40)},
 	}
 
-	encoder := newStructEncoder(0x30, structEncoderOptionRoot(rootToken))
+	encoder := newStructEncoder(0x30, structEncoderOptionRoot(rootToken),
+		structEncoderOptionConfig(&structEncoderConfig{
+			ZeroFields: true,
+			TagName:    "yomo",
+		}))
 	inputBuf, _ := encoder.Encode(input,
 		createSignal(0x02).SetString("a"),
 		createSignal(0x03).SetString("b"))

tester.go

@@ -7,7 +7,7 @@ import (
 
 var (
 	// enabledTestPrintf set whether to print debug information in the test
-	enabledTestPrintf = true
+	enabledTestPrintf = false
 )
 
 // observableTester use Observable to listen the node

types.go

@@ -8,7 +8,7 @@ import (
 
 // ToObject decode bytes to interface
 func ToObject(v []byte, output interface{}) error {
-	output, err := newStructDecoder(output).Decode(v)
+	output, err := newStructDecoder(output).Decode(v) // nolint
 	return err
 }