Allow for easy creating of custom tasks to be created allowing fields to have custom functions as generators

Author: Martin Simango

README.md

@@ -151,6 +151,8 @@ func main() {
 		AddField("Person", Person{Name: "Martin", Age: 25}, `json:"person"`).
 		AddField("Job", "Software Developer", "")
 
+		
+
 	strct := structBuilder.Build().Instance()
 
 	generatedStruct := dstruct.NewGeneratedStruct(strct)

dreflect/dreflect.go

@@ -112,7 +112,7 @@ func convert(src reflect.Value, dst reflect.Value) reflect.Value {
 		}
 
 		retPointer := reflect.New(dst.Type())
-		//enure that new pointer uses same memory address as src pointer
+		//ensure that new pointer uses same memory address as src pointer
 		reflect.NewAt(src.Type(), unsafe.Pointer(retPointer.Elem().UnsafeAddr())).Elem().
 			Set(src)
 

field.go

@@ -1,6 +1,10 @@
 package dstruct
 
-import "reflect"
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+)
 
 type structField struct {
 	name              string
@@ -35,3 +39,24 @@ func (f structField) GetFieldFQName() string {
 func (f structField) GetTag(t string) string {
 	return f.tag.Get(t)
 }
+
+func (f structField) GetJsonName() string {
+	return f.jsonName
+}
+
+func (f structField) GetEnumValues() (enumValues map[string]int) {
+	enum, ok := f.tag.Lookup("enum")
+	if ok {
+		numEnums, err := strconv.Atoi(enum)
+		if err != nil {
+			return
+		}
+		enumValues = make(map[string]int)
+		for i := 1; i <= numEnums; i++ {
+			if key := f.tag.Get(fmt.Sprintf("enum_%d", i)); key != "" {
+				enumValues[key] = i
+			}
+		}
+	}
+	return
+}

generator/basic.functions.go

@@ -11,7 +11,8 @@ import (
 
 type basicGenerationFunction struct {
 	_func func(...any) any
-	args  []any
+	// TODO consider making args exportable for more customizable generation functions
+	args []any
 }
 
 const ISO8601 string = "2018-03-20T09:12:28Z"

generator/functions.go

@@ -55,6 +55,7 @@ func GenerateNumberFunc[n number](min, max n) GenerationFunction {
 	}
 
 	f.args = []any{&min, &max}
+
 	return f
 }
 

generator/generated.field.go

@@ -6,8 +6,6 @@ import (
 	"strconv"
 )
 
-type ParentType map[string]int
-
 type GeneratedField struct {
 	Name         string
 	Value        reflect.Value
@@ -155,9 +153,17 @@ func (field *GeneratedField) getGenerationFunction() GenerationFunction {
 		return GenerateFixedValueFunc(tags.Get(fmt.Sprintf("enum_%d", generateNum(0, numEnums-1)+1)))
 	}
 
-	gen_task, ok := tags.Lookup("gen_task")
+	_, ok = tags.Lookup("gen_task")
 	if ok {
-		return getTask(gen_task, field.Name).getFunction()
+		taskProperties, err := CreateTaskProperties(field.Name, tags)
+		if err != nil {
+			panic(fmt.Sprintf("Error decoding gen_task: %s", err.Error()))
+		}
+		task := GetTask(taskProperties.TaskName)
+		if task == nil {
+			panic(fmt.Sprintf("Unregistered task %s", taskProperties.TaskName))
+		}
+		return task.GenerationFunction(*taskProperties)
 	}
 	return field.Generator.DefaultGenerationFunctions[kind]
 }

generator/generator.go

@@ -6,6 +6,8 @@ import (
 
 type GenerationFunction interface {
 	Generate() any
+	// Copy copies the generation config and returns a copy of it with the same config
+	// as the origin generation config
 	Copy(*GenerationConfig) GenerationFunction
 	GetGenerationConfig() *GenerationConfig
 	SetGenerationConfig(*GenerationConfig) GenerationFunction

generator/task.go

@@ -2,83 +2,92 @@ package generator
 
 import (
 	"fmt"
+	"reflect"
 	"strconv"
 	"strings"
 )
 
 type TaskName string
 
-const (
-	GenInt32 TaskName = "GenInt32"
-)
+type Task interface {
+	GenerationFunction(taskProperties TaskProperties) GenerationFunction
+	ExpectedParameterCount() int
+	Name() string
+}
+
+var tasks map[string]Task
 
-type Task struct {
-	Name       TaskName
-	Parameters string
+func init() {
+	tasks = make(map[string]Task)
+}
+
+type TaskProperties struct {
+	TaskName   string
+	Parameters []string
 	FieldName  string
 }
 
-type GenInt32Params struct {
-	min int32
-	max int32
+func GetTask(task string) Task {
+	return tasks[task]
 }
 
-func (t *Task) GenInt32Params() GenInt32Params {
-	params := strings.Split(t.Parameters, ",")
+func AddTask(task Task) error {
+	name := task.Name()
+	if tasks[name] != nil {
+		return fmt.Errorf("Task with name %s already exists", name)
+	}
+	tasks[name] = task
+	return nil
+}
 
-	if len(params) != 2 {
-		panic(fmt.Sprintf("error with field %s: task %s: task requires 2 parameters but has %d", t.FieldName, t.Name, len(params)))
+func getParameters(parameterCount int, tags reflect.StructTag) (parameters []string) {
+	for i := 1; i <= parameterCount; i++ {
+		parameters = append(parameters, tags.Get(fmt.Sprintf("gen_task_%d", i)))
 	}
-	param_1, err := strconv.Atoi(params[0])
-	if err != nil {
-		panic(fmt.Sprintf("error with field %s: task %s error: %s", t.FieldName, t.Name, err))
+	return parameters
+}
+
+func CreateTaskProperties(fieldName string, tags reflect.StructTag) (*TaskProperties, error) {
+	gen_task_tag := strings.TrimSpace(tags.Get("gen_task"))
+	leftBraceIndex := strings.Index(gen_task_tag, "(")
+	if leftBraceIndex == -1 {
+		return nil, fmt.Errorf("error with field %s: task %s error: no ( found", fieldName, gen_task_tag)
 	}
 
-	param_2, err := strconv.Atoi(params[1])
+	if gen_task_tag[len(gen_task_tag)-1:] != ")" {
+		return nil, fmt.Errorf("error with field %s: task %s error: last character of task must be )", fieldName, gen_task_tag)
+	}
+	taskName := gen_task_tag[:leftBraceIndex]
+	parameterCount, err := strconv.Atoi(gen_task_tag[leftBraceIndex+1 : len(gen_task_tag)-1])
 	if err != nil {
-		panic(fmt.Sprintf("error with field %s: task %s error: %s", t.FieldName, t.Name, err))
+		return nil, fmt.Errorf("error getting task parameter count: %w", err)
 	}
 
-	if param_1 > param_2 {
-		err = fmt.Errorf("min must be less or equal to the max value min = %d max = %d", param_1, param_2)
-		panic(fmt.Sprintf("error with field %s: task %s error: %s", t.FieldName, t.Name, err))
+	return &TaskProperties{
+		TaskName:   taskName,
+		Parameters: getParameters(parameterCount, tags),
+		FieldName:  fieldName,
+	}, nil
+}
 
-	}
+func GetTagForTask(name TaskName, params ...any) reflect.StructTag {
 
-	return GenInt32Params{
-		min: int32(param_1),
-		max: int32(param_2),
+	if tasks[string(name)] == nil {
+		panic(fmt.Sprintf("Task '%s' is not registered", name))
 	}
-}
 
-func getTask(task string, fieldName string) Task {
-	task = strings.TrimSpace(task)
-	leftBraceIndex := strings.Index(task, "(")
-	if leftBraceIndex == -1 {
-		panic(fmt.Sprintf("error with field %s: task %s error: no ( found", fieldName, task))
+	tags := fmt.Sprintf(`gen_task:"%s(%d)"`, name, len(params))
+	for i, p := range params {
+		tags += fmt.Sprintf(` gen_task_%d:"%v"`, (i + 1), p)
 	}
 
-	if task[len(task)-1:] != ")" {
-		panic(fmt.Sprintf("error with field %s: task %s error: last character of task must be )", fieldName, task))
-	}
-	taskName := task[:leftBraceIndex]
-	parameters := task[leftBraceIndex+1 : len(task)-1]
-	return Task{
-		Name:       TaskName(taskName),
-		Parameters: parameters,
-		FieldName:  fieldName,
-	}
+	return reflect.StructTag(tags)
+
 }
 
-func (t Task) getFunction() GenerationFunction {
-	switch t.Name {
-	case GenInt32:
-		params := t.GenInt32Params()
-		return GenerateNumberFunc(params.min, params.max)
+func validateParamCount(task Task, taskProperties TaskProperties) {
+	if len(taskProperties.Parameters) != task.ExpectedParameterCount() {
+		panic(fmt.Sprintf("error with field %s. task '%s': task requires %d parameters but has %d", taskProperties.FieldName, task.Name(), task.ExpectedParameterCount(), len(taskProperties.Parameters)))
 	}
-	panic(fmt.Sprintf("Invalid task name '%s' for field %s ", t.Name, t.FieldName))
-}
 
-func GetTagsForGenInt32Task(min int32, max int32) string {
-	return fmt.Sprintf(`gen_task:"%s(%d,%d)"`, GenInt32, min, max)
 }

go.mod

@@ -1,6 +1,13 @@
 module github.com/MartinSimango/dstruct
 
-go 1.20
+go 1.21.3
+
+
+retract v1.1.1
+retract v1.1.0
+retract v1.0.0
+retract v0.1.2
+retract v0.1.1
 
 require (
 	github.com/stretchr/testify v1.8.1

modifier.go

@@ -31,7 +31,9 @@ type DynamicStructModifier interface {
 	// GetFields returns a map containing all fields within a struct
 	GetFields() FieldData
 
-	// Update updates the struct's underlying tree to represent that of the strct's value
+	// Update updates the struct's underlying tree to represent that of the strct's value.
+	// The structs underlying tree can change if new fields are added due to fields within the struct changing from
+	// nil to become not nil. This can lead to new additional fields being introduced within the struct
 	Update()
 
 	// Apply is a combination of Set and Update. Update is not called if Apply fails.