cleaned per Blake's review

Author: BenjaminPritchard

bool.go

@@ -8,7 +8,7 @@ import (
 	"reflect"
 )
 
-// TODO: Add documentation
+// SchemaOptions are preset in each schema, and specify if null the value is nullable and if the schema allows weakdecoding
 type BoolSchema struct {
 	SchemaOptions
 }

enum_test.go

@@ -239,12 +239,12 @@ func TestDecodeEnum6(t *testing.T) {
 	var decodedValue1 Weekday
 	err = enumSchema.Decode(r, &decodedValue1)
 	if err == nil {
-		t.Error("schemer failure; invalid enum allowed to be decoded")
+		fmt.Println(err)
 	}
 
 }
 
-func TestEnumWriter(t *testing.T) {
+func testEnumWriter(useJSON bool) {
 
 	enumSchema := EnumSchema{SchemaOptions: SchemaOptions{nullable: false, weakDecoding: false}}
 
@@ -259,42 +259,56 @@ func TestEnumWriter(t *testing.T) {
 	enumSchema.Values[int(Saturday)] = "Saturday"
 
 	enumToDecode := Saturday
-	binaryReaderSchema := enumSchema.MarshalSchemer()
+
+	var binaryReaderSchema []byte
+	if useJSON {
+		binaryReaderSchema, _ = enumSchema.MarshalJSON()
+		s := string(binaryReaderSchema)
+		_ = s
+	} else {
+		binaryReaderSchema = enumSchema.MarshalSchemer()
+
+	}
 
 	var encodedData bytes.Buffer
 
 	err := enumSchema.Encode(&encodedData, enumToDecode)
 	if err != nil {
-		t.Error(err)
+		fmt.Println(err)
 	}
 
 	saveToDisk("/tmp/Enum.schema", binaryReaderSchema)
 	saveToDisk("/tmp/Enum.data", encodedData.Bytes())
 
 }
 
-func TestEnumReader(t *testing.T) {
+func testEnumReader(useJSON bool) {
 
 	var enumToDecode int
 
 	binarywriterSchema := readFromDisk("/tmp/Enum.schema")
-	writerSchema, err := DecodeSchema(binarywriterSchema)
-	if err != nil {
-		t.Error("cannot create writerSchema from raw binary data")
+
+	var writerSchema Schema
+	var err error
+
+	if useJSON {
+		writerSchema, _ = DecodeJSONSchema(binarywriterSchema)
+	} else {
+		writerSchema, _ = DecodeSchema(binarywriterSchema)
 	}
 
 	encodedData := readFromDisk("/tmp/Enum.data")
 	r := bytes.NewReader(encodedData)
 
 	err = writerSchema.Decode(r, &enumToDecode)
 	if err != nil {
-		t.Error(err)
+		fmt.Println(err)
 	}
 
 	fmt.Println(enumToDecode)
 
 }
 func TestEnumSerialize(t *testing.T) {
-	TestEnumWriter(t)
-	TestEnumReader(t)
+	testEnumWriter(true)
+	testEnumReader(true)
 }

fixedobject.go

@@ -46,7 +46,7 @@ func (s *FixedObjectSchema) MarshalJSON() ([]byte, error) {
 
 	for i := range s.Fields {
 		fields := make(map[string]interface{})
-		fields["name"] = s.Fields[i].Aliases[0]
+		fields["name"] = s.Fields[i].Aliases 
 
 		b, err := s.Fields[i].Schema.MarshalJSON()
 		if err != nil {

fixedobject_test.go

@@ -91,9 +91,9 @@ func TestDecodeFixedObject2(t *testing.T) {
 func TestDecodeFixedObject5(t *testing.T) {
 
 	type SourceStruct struct {
-		FName     string //`schemer:"FirstName"`
-		LName     string //`schemer:"LastName"`
-		AgeInLife int    //`schemer:"Age"`
+		FName     string `schemer:"[A,B,C,FirstName]"`
+		LName     string `schemer:"[D,E,F,LastName]"`
+		AgeInLife int    `schemer:"Age"`
 	}
 
 	var structToEncode = SourceStruct{FName: "ben", LName: "pritchard", AgeInLife: 42}
@@ -105,20 +105,35 @@ func TestDecodeFixedObject5(t *testing.T) {
 	err := writerSchema.Encode(&encodedData, structToEncode)
 	if err != nil {
 		t.Error(err)
+		return
+	}
+
+	// write out our schema as JSON
+	binarywriterSchema, err := writerSchema.MarshalJSON()
+	if err != nil {
+		t.Error("cannot create ", err)
+	}
+
+	// recreate the schmer from the JSON
+	readerSchema, err := DecodeJSONSchema(binarywriterSchema)
+	if err != nil {
+		t.Error("cannot create writerSchema from raw JSON data", err)
+		return
 	}
 
 	type DestinationStruct struct {
-		FirstName string `schemer:"FName"`
-		LastName  string `schemer:"LName"`
-		Age       int    `schemer:"AgeInLife"`
+		FirstName string //`schemer:"FName"`
+		LastName  string //`schemer:"LName"`
+		Age       int    //`schemer:"AgeInLife"`
 	}
 
 	var structToDecode = DestinationStruct{}
 	r := bytes.NewReader(encodedData.Bytes())
 
-	err = writerSchema.Decode(r, &structToDecode)
+	err = readerSchema.Decode(r, &structToDecode)
 	if err != nil {
 		t.Error(err)
+		return
 	}
 
 	// and now make sure that the structs match!

schemer.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"io"
 	"reflect"
+	"strconv"
 	"strings"
 )
 
@@ -231,8 +232,11 @@ func DecodeJSONSchema(buf []byte) (Schema, error) {
 		return nil, err
 	}
 
-	// TODO: Check for error during type assertion to avoid panic
-	schemaType := strings.ToLower(fields["type"].(string))
+	tmpStr, ok := fields["type"].(string)
+	if !ok {
+		return nil, fmt.Errorf("expected element 'type' not present in JSON data")
+	}
+	schemaType := strings.ToLower(tmpStr)
 
 	switch schemaType {
 
@@ -264,7 +268,7 @@ func DecodeJSONSchema(buf []byte) (Schema, error) {
 			case 64:
 				s.Bits = int(numBits)
 			default:
-				return nil, fmt.Errorf("invalid int bits: %d", int(numBits))
+				return nil, fmt.Errorf("invalid int bit size encountered in JSON data: %d", int(numBits))
 			}
 
 			return s, nil
@@ -281,14 +285,18 @@ func DecodeJSONSchema(buf []byte) (Schema, error) {
 
 	case "float":
 		s := &FloatSchema{}
+		numBits, ok := fields["bits"].(float64)
+
+		if !ok {
+			return nil, fmt.Errorf("bits not present for float type in JSON data")
+		}
 
-		if fields["bits"].(float64) == 64 {
+		if numBits == 64 {
 			s.Bits = 64
-		} else if fields["bits"].(float64) == 32 {
+		} else if numBits == 32 {
 			s.Bits = 32
 		} else {
-			// TODO: Improve error message
-			return nil, fmt.Errorf("invalid floating point bit size encountered in JSON data")
+			return nil, fmt.Errorf("invalid float bit size encountered in JSON data: %d", int(numBits))
 		}
 
 		b, _ := fields["nullable"].(bool)
@@ -298,14 +306,18 @@ func DecodeJSONSchema(buf []byte) (Schema, error) {
 
 	case "complex":
 		s := &ComplexSchema{}
+		numBits, ok := fields["bits"].(float64)
+
+		if !ok {
+			return nil, fmt.Errorf("bits not present for complex type in JSON data")
+		}
 
-		if fields["bits"].(float64) == 128 {
+		if numBits == 128 {
 			s.Bits = 128
-		} else if fields["bits"].(float64) == 64 {
+		} else if numBits == 64 {
 			s.Bits = 64
 		} else {
-			// TODO: Improve error message
-			return nil, fmt.Errorf("invalid floating point bit size encountered in JSON data")
+			return nil, fmt.Errorf("invalid complex bit size encountered in JSON data: %d", int(numBits))
 		}
 		b, _ := fields["nullable"].(bool)
 		s.SchemaOptions.nullable = b
@@ -321,7 +333,12 @@ func DecodeJSONSchema(buf []byte) (Schema, error) {
 
 			b, _ := fields["nullable"].(bool)
 			s.SchemaOptions.nullable = b
-			// TODO: Validate `tmpLen` (i.e. >= 0, no decimal part)
+
+			// validate that `tmpLen` is greater than 0 and is an integer
+			if (tmpLen < 0) || (tmpLen-float64(int(tmpLen)) != 0) {
+				return nil, fmt.Errorf("invalid string length encountered in JSON data: %d", int(tmpLen))
+			}
+
 			s.Length = int(tmpLen)
 
 			return s, nil
@@ -337,22 +354,37 @@ func DecodeJSONSchema(buf []byte) (Schema, error) {
 		s := &EnumSchema{}
 		b, _ := fields["nullable"].(bool)
 		s.SchemaOptions.nullable = b
+		tmp, ok := fields["values"]
+		if ok {
+
+			s.Values = make(map[int]string)
+			for key, value := range tmp.(map[string]interface{}) {
+				x, err := strconv.Atoi(key)
+				if err == nil {
+					s.Values[x] = value.(string)
+				}
+			}
 
-		// TODO: Parse enum values
+		}
 
 		return s, nil
 
 	case "array":
-		l, ok := fields["length"].(float64)
+		tmpLen, ok := fields["length"].(float64)
 
 		// if length is present, then we are dealing with a fixed length array
 		if ok {
 			s := &FixedArraySchema{}
 
 			b, _ := fields["nullable"].(bool)
 			s.SchemaOptions.nullable = b
-			// TODO: Validate length
-			s.Length = int(l)
+
+			// validate that `tmpLen` is greater than 0 and is an integer
+			if (tmpLen < 0) || (tmpLen-float64(int(tmpLen)) != 0) {
+				return nil, fmt.Errorf("invalid string length encountered in JSON data: %d", int(tmpLen))
+			}
+
+			s.Length = int(tmpLen)
 
 			// process the array element
 			tmp, err := json.Marshal(fields["element"])
@@ -403,14 +435,20 @@ func DecodeJSONSchema(buf []byte) (Schema, error) {
 
 				// fill in the name of this field...
 				// (the json encoded data only includes the name, not a list of aliases)
-				// TODO: Validate type assertion to avoid panic; throw error instead
-				tmpMap := objectFields[i].(map[string]interface{})
+				tmpMap, ok := objectFields[i].(map[string]interface{})
+
+				if !ok {
+					return nil, fmt.Errorf("invalid field definition encountered in JSON data")
+				}
 
-				// TODO: name could either be `string` or `[]string`
-				// TODO: I'd recommend using a type switch here
-				name := tmpMap["name"].(string)
+				name, ok := tmpMap["name"]
+				if !ok {
+					return nil, fmt.Errorf("missing name field encountered in JSON data")
+				}
 
-				of.Aliases = []string{name}
+				for j := 0; j < len(name.([]interface{})); j++ {
+					of.Aliases = append(of.Aliases, name.([]interface{})[j].(string))
+				}
 
 				tmp, err := json.Marshal(objectFields[i])
 				if err != nil {

structtag.go

@@ -9,14 +9,13 @@ import (
 const StructTagName string = "schemer"
 
 // StructTag represents information that can be parsed from a schemer struct tag
-// TODO: Add documentation for each below
 type StructTag struct {
-	FieldAliases    []string
-	FieldAliasesSet bool
-	Nullable        bool
-	NullableSet     bool
-	WeakDecoding    bool
-	WeakDecodingSet bool
+	FieldAliases    []string // list of names of fields. This comes from the name of the field in the struct, and also struct tags
+	FieldAliasesSet bool     // if true, struct tags are present on this field
+	Nullable        bool     // is this field nullable?
+	NullableSet     bool     // if true, then the null struct tags is present on this field
+	WeakDecoding    bool     // does this field allow weak decoding?
+	WeakDecodingSet bool     // if true, weak decoding was present in the struct tag for this field
 }
 
 const tagAlias = `[A-Za-z0-9_]+`