Datadictionary/Gen refactor (#140)

* name cleanup

* gen fields refactor

Author: cbusbey

datadictionary/datadictionary.go

@@ -127,7 +127,7 @@ type FieldDef struct {
 	required bool
 
 	Parts          []MessagePart
-	ChildFields    []*FieldDef
+	Fields         []*FieldDef
 	requiredParts  []MessagePart
 	requiredFields []*FieldDef
 }
@@ -154,14 +154,14 @@ func NewGroupFieldDef(fieldType *FieldType, required bool, parts []MessagePart)
 		}
 
 		if comp, ok := part.(Component); ok {
-			field.ChildFields = append(field.ChildFields, comp.Fields()...)
+			field.Fields = append(field.Fields, comp.Fields()...)
 
 			if comp.required {
 				field.requiredFields = append(field.requiredFields, comp.requiredFields...)
 			}
 		} else {
 			if child, ok := part.(*FieldDef); ok {
-				field.ChildFields = append(field.ChildFields, child)
+				field.Fields = append(field.Fields, child)
 
 				if child.required {
 					field.requiredFields = append(field.requiredFields, child)
@@ -181,7 +181,7 @@ func (f FieldDef) Required() bool { return f.required }
 
 //IsGroup is true if the field is a repeating group.
 func (f FieldDef) IsGroup() bool {
-	return len(f.ChildFields) > 0
+	return len(f.Fields) > 0
 }
 
 //RequiredParts returns those parts that are required for this FieldDef. IsGroup
@@ -193,9 +193,9 @@ func (f FieldDef) RequiredParts() []MessagePart { return f.requiredParts }
 func (f FieldDef) RequiredFields() []*FieldDef { return f.requiredFields }
 
 func (f FieldDef) childTags() []int {
-	tags := make([]int, 0, len(f.ChildFields))
+	tags := make([]int, 0, len(f.Fields))
 
-	for _, f := range f.ChildFields {
+	for _, f := range f.Fields {
 		tags = append(tags, f.Tag())
 		for _, t := range f.childTags() {
 			tags = append(tags, t)
@@ -208,7 +208,7 @@ func (f FieldDef) childTags() []int {
 func (f FieldDef) requiredChildTags() []int {
 	var tags []int
 
-	for _, f := range f.ChildFields {
+	for _, f := range f.Fields {
 		if !f.Required() {
 			continue
 		}

gen/generate-fields/main.go

@@ -10,23 +10,16 @@ import (
 	"github.com/quickfixgo/quickfix/gen"
 )
 
-var (
-	fieldMap     map[string]int
-	fieldTypeMap map[string]*datadictionary.FieldType
-	sortedTags   []string
-)
-
 func usage() {
 	fmt.Fprintf(os.Stderr, "usage: generate-fields [flags] <path to data dictionary> ... \n")
 	flag.PrintDefaults()
 	os.Exit(2)
 }
 
-func genEnums() error {
+func genEnums(fieldTypes []*datadictionary.FieldType) error {
 	fileOut := "package enum\n"
 
-	for _, fieldName := range sortedTags {
-		fieldType, _ := fieldTypeMap[fieldName]
+	for _, fieldType := range fieldTypes {
 		if len(fieldType.Enums) == 0 {
 			continue
 		}
@@ -39,27 +32,26 @@ func genEnums() error {
 		}
 		sort.Strings(sortedEnums)
 
-		fileOut += fmt.Sprintf("//Enum values for %v\n", fieldName)
+		fileOut += fmt.Sprintf("//Enum values for %v\n", fieldType.Name())
 		fileOut += "const(\n"
 		for _, enumVal := range sortedEnums {
 			enum, _ := fieldType.Enums[enumVal]
-			fileOut += fmt.Sprintf("%v_%v = \"%v\"\n", fieldName, enum.Description, enum.Value)
+			fileOut += fmt.Sprintf("%v_%v = \"%v\"\n", fieldType.Name(), enum.Description, enum.Value)
 		}
 		fileOut += ")\n"
 	}
 
 	return gen.WriteFile("enum/enums.go", fileOut)
 }
 
-func genFields() error {
+func genFields(fieldTypes []*datadictionary.FieldType) error {
 	fileOut := "package field\n"
 	fileOut += "import(\n"
 	fileOut += "\"github.com/quickfixgo/quickfix\"\n"
 	fileOut += "\"" + gen.GetImportPathRoot() + "/tag\"\n"
 	fileOut += ")\n"
 
-	for _, tag := range sortedTags {
-		field := fieldTypeMap[tag]
+	for _, field := range fieldTypes {
 
 		baseType := ""
 		goType := ""
@@ -140,7 +132,7 @@ func genFields() error {
 			goType = "float64"
 
 		default:
-			return fmt.Errorf("Unknown type '%v' for tag '%v'\n", field.Type, tag)
+			return fmt.Errorf("Unknown type '%v' for tag '%v'\n", field.Type, field.Tag())
 		}
 
 		fileOut += fmt.Sprintf("//%vField is a %v field\n", field.Name(), field.Type)
@@ -160,19 +152,25 @@ func genFields() error {
 	return gen.WriteFile("field/fields.go", fileOut)
 }
 
-func genTags() error {
+func genTags(fieldTypes []*datadictionary.FieldType) error {
 	fileOut := "package tag\n"
 	fileOut += "import(\"github.com/quickfixgo/quickfix\")\n"
 
 	fileOut += "const (\n"
-	for _, tag := range sortedTags {
-		fileOut += fmt.Sprintf("%v quickfix.Tag = %v\n", tag, fieldMap[tag])
+	for _, f := range fieldTypes {
+		fileOut += fmt.Sprintf("%v quickfix.Tag = %v\n", f.Name(), f.Tag())
 	}
 	fileOut += ")\n"
 
 	return gen.WriteFile("tag/tag_numbers.go", fileOut)
 }
 
+type byFieldName []*datadictionary.FieldType
+
+func (n byFieldName) Len() int           { return len(n) }
+func (n byFieldName) Swap(i, j int)      { n[i], n[j] = n[j], n[i] }
+func (n byFieldName) Less(i, j int) bool { return n[i].Name() < n[j].Name() }
+
 func main() {
 	flag.Usage = usage
 	flag.Parse()
@@ -181,8 +179,7 @@ func main() {
 		usage()
 	}
 
-	fieldMap = make(map[string]int)
-	fieldTypeMap = make(map[string]*datadictionary.FieldType)
+	fieldTypeMap := make(map[string]*datadictionary.FieldType)
 
 	for _, dataDict := range flag.Args() {
 		spec, err := datadictionary.Parse(dataDict)
@@ -193,8 +190,6 @@ func main() {
 		}
 
 		for _, field := range spec.FieldTypeByTag {
-			fieldMap[field.Name()] = field.Tag()
-
 			if oldField, ok := fieldTypeMap[field.Name()]; ok {
 				//merge old enums with new
 				if len(oldField.Enums) > 0 && field.Enums == nil {
@@ -223,17 +218,18 @@ func main() {
 		}
 	}
 
-	sortedTags = make([]string, len(fieldMap))
+	fieldTypes := make([]*datadictionary.FieldType, len(fieldTypeMap))
 	i := 0
-	for f := range fieldMap {
-		sortedTags[i] = f
+	for _, fieldType := range fieldTypeMap {
+		fieldTypes[i] = fieldType
 		i++
 	}
-	sort.Strings(sortedTags)
+
+	sort.Sort(byFieldName(fieldTypes))
 
 	var h gen.ErrorHandler
-	h.Handle(genTags())
-	h.Handle(genFields())
-	h.Handle(genEnums())
+	h.Handle(genTags(fieldTypes))
+	h.Handle(genFields(fieldTypes))
+	h.Handle(genEnums(fieldTypes))
 	os.Exit(h.ReturnCode)
 }

validation.go

@@ -189,8 +189,8 @@ func validateVisitGroupField(fieldDef *datadictionary.FieldDef, fieldStack []Tag
 	for len(fieldStack) > 0 {
 
 		//start of repeating group
-		if int(fieldStack[0].tag) == fieldDef.ChildFields[0].Tag() {
-			childDefs = fieldDef.ChildFields
+		if int(fieldStack[0].tag) == fieldDef.Fields[0].Tag() {
+			childDefs = fieldDef.Fields
 			groupCount++
 		}
 

validation_test.go

@@ -25,10 +25,10 @@ func TestValidate(t *testing.T) {
 		tcInvalidMsgType(),
 		tcValueIsIncorrect(),
 		tcIncorrectDataFormatForValue(),
-		tcTagSpecifiedOutOfRequiredOrder_Header(),
-		tcTagSpecifiedOutOfRequiredOrder_Trailer(),
-		tcTagSpecifiedOutOfRequiredOrder_Disabled_Header(),
-		tcTagSpecifiedOutOfRequiredOrder_Disabled_Trailer(),
+		tcTagSpecifiedOutOfRequiredOrderHeader(),
+		tcTagSpecifiedOutOfRequiredOrderTrailer(),
+		tcTagSpecifiedOutOfRequiredOrderDisabledHeader(),
+		tcTagSpecifiedOutOfRequiredOrderDisabledTrailer(),
 		tcTagAppearsMoreThanOnce(),
 		tcFloatValidation(),
 		tcTagNotDefinedForMessage(),
@@ -336,7 +336,7 @@ func tcIncorrectDataFormatForValue() validateTest {
 	}
 }
 
-func tcTagSpecifiedOutOfRequiredOrder_Header() validateTest {
+func tcTagSpecifiedOutOfRequiredOrderHeader() validateTest {
 	dict, _ := datadictionary.Parse("spec/FIX40.xml")
 	validator := &fixValidator{dict, defaultValidatorSettings}
 
@@ -355,7 +355,7 @@ func tcTagSpecifiedOutOfRequiredOrder_Header() validateTest {
 	}
 }
 
-func tcTagSpecifiedOutOfRequiredOrder_Trailer() validateTest {
+func tcTagSpecifiedOutOfRequiredOrderTrailer() validateTest {
 	dict, _ := datadictionary.Parse("spec/FIX40.xml")
 	validator := &fixValidator{dict, defaultValidatorSettings}
 
@@ -375,7 +375,7 @@ func tcTagSpecifiedOutOfRequiredOrder_Trailer() validateTest {
 	}
 }
 
-func tcTagSpecifiedOutOfRequiredOrder_Disabled_Header() validateTest {
+func tcTagSpecifiedOutOfRequiredOrderDisabledHeader() validateTest {
 	dict, _ := datadictionary.Parse("spec/FIX40.xml")
 	validator := &fixValidator{dict, defaultValidatorSettings}
 	validator.settings.CheckFieldsOutOfOrder = false
@@ -394,7 +394,7 @@ func tcTagSpecifiedOutOfRequiredOrder_Disabled_Header() validateTest {
 	}
 }
 
-func tcTagSpecifiedOutOfRequiredOrder_Disabled_Trailer() validateTest {
+func tcTagSpecifiedOutOfRequiredOrderDisabledTrailer() validateTest {
 	dict, _ := datadictionary.Parse("spec/FIX40.xml")
 	validator := &fixValidator{dict, defaultValidatorSettings}
 	validator.settings.CheckFieldsOutOfOrder = false
@@ -445,13 +445,13 @@ func TestValidateVisitField(t *testing.T) {
 	fieldDef0 := &datadictionary.FieldDef{FieldType: fieldType0}
 
 	fieldType1 := datadictionary.NewFieldType("myfield", 2, "STRING")
-	fieldDef1 := &datadictionary.FieldDef{FieldType: fieldType1, ChildFields: []*datadictionary.FieldDef{}}
+	fieldDef1 := &datadictionary.FieldDef{FieldType: fieldType1, Fields: []*datadictionary.FieldDef{}}
 
 	fieldType2 := datadictionary.NewFieldType("myfield", 3, "STRING")
-	fieldDef2 := &datadictionary.FieldDef{FieldType: fieldType2, ChildFields: []*datadictionary.FieldDef{}}
+	fieldDef2 := &datadictionary.FieldDef{FieldType: fieldType2, Fields: []*datadictionary.FieldDef{}}
 
 	groupFieldType := datadictionary.NewFieldType("mygroupfield", 1, "INT")
-	groupFieldDef := &datadictionary.FieldDef{FieldType: groupFieldType, ChildFields: []*datadictionary.FieldDef{fieldDef1, fieldDef2}}
+	groupFieldDef := &datadictionary.FieldDef{FieldType: groupFieldType, Fields: []*datadictionary.FieldDef{fieldDef1, fieldDef2}}
 
 	var field TagValue
 	field.init(Tag(11), []byte("value"))