generate output

src/gen/generator.go

@@ -10,21 +10,21 @@ import (
 )
 
 func GenerateForDefinition(defFile string, fieldsToExport []string, total int) ([][]string, []bool) {
-	constant.RootDef = LoadRootDef(defFile)
-	constant.ReferedValues = LoadClsDef(defFile, fieldsToExport)
+	constant.Def = LoadRootDef(defFile)
+	constant.Res = LoadResDef(fieldsToExport)
 
 	fieldNameToValues := map[string][]string{}
 
 	colTypes := make([]bool, 0)
 
 	// 为每个field生成值列表
-	for index, field := range constant.RootDef.Fields {
+	for index, field := range constant.Def.Fields {
 		if !stringUtils.FindInArr(field.Field, fieldsToExport) {
 			continue
 		}
 
 		values := GenerateForField(&field, total)
-		constant.RootDef.Fields[index].Precision = field.Precision
+		constant.Def.Fields[index].Precision = field.Precision
 
 		fieldNameToValues[field.Field] = values
 		colTypes = append(colTypes, field.IsNumb)
@@ -33,7 +33,7 @@ func GenerateForDefinition(defFile string, fieldsToExport []string, total int) (
 	// 生成指定数量行的数据
 	rows := make([][]string, 0)
 	for i := 0; i < total; i++ {
-		for _, field := range constant.RootDef.Fields {
+		for _, field := range constant.Def.Fields {
 			if !stringUtils.FindInArr(field.Field, fieldsToExport) {
 				continue
 			}
@@ -69,10 +69,10 @@ func GenerateForField(field *model.DefField,  total int) []string {
 		}
 		values = LoopSubFields(field, values, total)
 
-	} else if field.From != "" { // refer field
-		groupValues := constant.ReferedValues[field.From]
+	} else if field.From != "" { // refer to res
+		groupValues := constant.Res[field.From]
 
-		if field.Use != "" { // refer to cls
+		if field.Use != "" { // refer to yaml
 			groups := strings.Split(field.Use, ",")
 			for _, group := range groups {
 				values = append(values, groupValues[group]...)

src/gen/cls.go → src/gen/res.go

@@ -14,33 +14,33 @@ import (
 	"strings"
 )
 
-func LoadClsDef(file string, fieldsToExport []string) map[string]map[string][]string {
-	referFieldValueMap := map[string]map[string][]string{}
+func LoadResDef(fieldsToExport []string) map[string]map[string][]string {
+	res := map[string]map[string][]string{}
 
-	for _, field := range constant.RootDef.Fields {
+	for _, field := range constant.Def.Fields {
 		if !stringUtils.FindInArr(field.Field, fieldsToExport) { continue }
 
-		loadClsField(&field, &referFieldValueMap)
+		loadResField(&field, &res)
 	}
 
-	return referFieldValueMap
+	return res
 }
 
-func loadClsField(field *model.DefField, referFieldValueMap *map[string]map[string][]string) {
+func loadResField(field *model.DefField, res *map[string]map[string][]string) {
 	if len(field.Fields) > 0 {
 		for _, child := range field.Fields {
-			loadClsField(&child, referFieldValueMap)
+			loadResField(&child, res)
 		}
 	} else if field.From != "" {
-		referFile, referType := getReferProp(field.From)
-		values, _ := getReferFieldValue(referFile, referType, field)
-		(*referFieldValueMap)[field.From] = values
+		resFile, resType := getResProp(field.From)
+		values, _ := getResValue(resFile, resType, field)
+		(*res)[field.From] = values
 	}
 }
 
-func getReferProp(from string) (string, string) {
-	referFile := ""
-	referType := ""
+func getResProp(from string) (string, string) {
+	resFile := ""
+	resType := ""
 
 	sep := string(os.PathSeparator)
 
@@ -49,100 +49,108 @@ func getReferProp(from string) (string, string) {
 		left := from[:index]
 		left = strings.ReplaceAll(left, ".", sep)
 
-		referFile = left + ".yaml"
-		referType = "yaml"
+		resFile = left + ".yaml"
+		resType = "yaml"
 	} else { // excel, system.address.china
 		index = strings.LastIndex(from, ".")
 
 		left := from[:index]
 		left = strings.ReplaceAll(left, ".", sep)
 
-		referFile = left + ".xlsx"
-		referType = "excel"
+		resFile = left + ".xlsx"
+		resType = "excel"
 	}
 
-	if strings.Index(referFile, "system") == -1 { // no system cls
-		referFile = vari.InputDir + referFile
+	if strings.Index(resFile, "system") == -1 { // no system cls
+		resFile = vari.InputDir + resFile
 
-		if !fileUtils.FileExist(referFile) { // not in input dir
-			referFile = vari.ExeDir + referFile
+		if !fileUtils.FileExist(resFile) { // not in input dir
+			resFile = vari.ExeDir + resFile
 
-			if !fileUtils.FileExist(referFile) { // not in exe dir
-				referFile = ""
+			if !fileUtils.FileExist(resFile) { // not in exe dir
+				resFile = ""
 			}
 		}
 	} else {
-		referFile = constant.ResDir + referFile
+		resFile = constant.ResDir + resFile
 	}
 
-	return referFile, referType
+	return resFile, resType
 }
 
-func getReferFieldValue(referFile string, referType string, field *model.DefField) (map[string][]string, string) {
-	name := ""
-	values := map[string][]string{}
+func getResValue(resFile string, resType string, field *model.DefField) (map[string][]string, string) {
+	resName := ""
+	groupedValues := map[string][]string{}
 
-	if referType == "yaml" {
-		values, name = getReferFieldValueForYaml(referFile)
-	} else if referType == "excel" {
-		values, name = getReferFieldValueForExcel(referFile, field)
+	if resType == "yaml" {
+		groupedValues, resName = getResForYaml(resFile)
+	} else if resType == "excel" {
+		groupedValues, resName = getResForExcel(resFile, field)
 	}
 
-	return values, name
+	return groupedValues, resName
 }
 
-func getReferFieldValueForYaml(referFile string) (map[string][]string, string) {
-	name := ""
+func getResForExcel(resFile string, field *model.DefField) (map[string][]string, string) {
+	valueMap, resName := GenerateFieldValuesFromExcel(resFile, field)
+
+	return valueMap, resName
+}
+
+func getResForYaml(resFile string) (map[string][]string, string) {
+	resName := ""
 	valueMap := map[string][]string{}
 
-	ranges := model.ClsRanges{}
+	ranges := model.ResRanges{}
 
-	yamlContent, err := ioutil.ReadFile(referFile)
+	yamlContent, err := ioutil.ReadFile(resFile)
 	if err != nil {
-		logUtils.Screen("fail to read " + referFile)
+		logUtils.Screen("fail to read " + resFile)
 		return valueMap, ""
 	}
 
 	err = yaml.Unmarshal(yamlContent, &ranges)
 	if err != nil || ranges.Ranges == nil || len(ranges.Ranges) == 0 { // instances
-		logUtils.Screen("not ClsRanges " + referFile + ", try to parse as ClsInsts")
+		logUtils.Screen("not ResRanges " + resFile + ", try to parse as ResInsts")
 
-		insts := model.ClsInsts{}
+		insts := model.ResInsts{}
 		err = yaml.Unmarshal(yamlContent, &insts)
 		if err != nil {
 			return valueMap, ""
 		} else {
-			valueMap = getReferFieldValueForInstances(insts)
+			valueMap = getResForInstances(insts)
 		}
 
-		name = insts.Field
+		resName = insts.Field
 
 	} else { // ranges
-		valueMap = getReferFieldValueForRanges(ranges)
-		name = ranges.Field
+		valueMap = getResForRanges(ranges)
+		resName = ranges.Field
 	}
 
-	return valueMap, name
+	return valueMap, resName
 }
 
-func getReferFieldValueForRanges(ranges model.ClsRanges) map[string][]string {
-	values := map[string][]string{}
+func getResForRanges(ranges model.ResRanges) map[string][]string {
+	groupedValue := map[string][]string{}
 
-	for name, exp := range ranges.Ranges {
-		// convert ranges refer to standard field
+	for group, exp := range ranges.Ranges {
+		// convert ranges field to standard field
 		tempField := model.DefField{Field: ranges.Field, Range: exp, Type: "cls"}
 
-		values[name] = GenerateFieldItemsFromDefinition(&tempField)
+		groupedValue[group] = GenerateFieldItemsFromDefinition(&tempField)
 	}
 
-	return values
+	return groupedValue
 }
 
-func getReferFieldValueForInstances(insts model.ClsInsts) map[string][]string {
-	values := map[string][]string{}
+func getResForInstances(insts model.ResInsts) map[string][]string {
+	groupedValue := map[string][]string{}
 
 	for _, inst := range insts.Instances {
-		// convert ranges refer to standard field
+		group := inst.Instance
+
+		// convert instant field to standard field
 		tempField := model.DefField{Field: insts.Field, Type: "cls"}
 
 		child := model.DefField{Field: inst.Instance}
@@ -150,14 +158,8 @@ func getReferFieldValueForInstances(insts model.ClsInsts) map[string][]string {
 
 		tempField.Fields = append(tempField.Fields, child)
 
-		values[inst.Instance] = GenerateForField(&tempField, constant.Total)
+		groupedValue[group] = GenerateForField(&tempField, constant.Total)
 	}
 
-	return values
-}
-
-func getReferFieldValueForExcel(referFile string, field *model.DefField) (map[string][]string, string) {
-	values, dbName := GenerateFieldValuesFromExcel(referFile, field)
-
-	return values, dbName
+	return groupedValue
 }
\ No newline at end of file

src/model/definition.go

@@ -7,20 +7,20 @@ type ClsBase struct {
 	Version string `yaml:"version"`
 }
 
-// range refer
-type ClsRanges struct {
+// range res
+type ResRanges struct {
 	ClsBase   `yaml:",inline"`
 	FieldBase   `yaml:",inline"`
 	Field string  `yaml:"field"`
 	Ranges map[string]string  `yaml:"ranges"`
 }
-// instance refer
-type ClsInsts struct {
+// instance res
+type ResInsts struct {
 	ClsBase   `yaml:",inline"`
-	Field string  `yaml:"field"`
-	Instances []ClsInst `yaml:"instances,flow"`
+	Field string        `yaml:"field"`
+	Instances []ResInst `yaml:"instances,flow"`
 }
-type ClsInst struct {
+type ResInst struct {
 	FieldBase   `yaml:",inline"`
 	Instance string  `yaml:"instance"`
 	Range    string  `yaml:"range"`

src/utils/const/const.go

@@ -28,11 +28,11 @@ var (
 	Total = 10
 	MaxNumb = 100000 // max number in array
 
-	RootDef       = model.DefData{}
-	ReferedValues = map[string]map[string][]string{}
+	Def = model.DefData{}
+	Res = map[string]map[string][]string{}
 
-	ResDir      = "data/"
-	ResBuildIn  = ResDir + "system/buildin.yaml"
+	ResDir  = "data/"
+	ResPath = ResDir + "system/buildin.yaml"
 
 	SqliteDriver  = "sqlite3"
 	SqliteSource  = "file:" + ResDir + ".cache/.data.db"