fix bugs - improve task code and add task example code

Author: MartinSimango

dstruct.generated.struct.go

@@ -54,7 +54,7 @@ func NewGeneratedStructWithConfig[T any](val T,
 	}
 
 	for _, v := range customTypes {
-		generatedStruct.addCustomType(v)
+		generatedStruct.AddCustomType(v)
 	}
 	generatedStruct.addCustomTypes()
 	generatedStruct.populateGeneratedFields(generatedStruct.root)
@@ -266,24 +266,18 @@ func (gs *DStructGeneratedStruct[T]) SetGenerationFunctions(
 	gs.propagateGenerationFunctions(gs.root, functions)
 }
 
-// SetFieldFromTask implements GeneratedStruct.SetFieldFromTask
-func (gs *DStructGeneratedStruct[T]) SetFieldFromTask(
+// SetFieldFromTaskInstance implements GeneratedStruct.SetFieldFromTaskInstanc
+func (gs *DStructGeneratedStruct[T]) SetFieldFromTaskInstance(
 	field string,
-	task generator.Task,
-	params ...any,
+	taskInstance generator.TaskInstance,
 ) error {
-	taskProperties, err := generator.CreateTaskProperties(
-		field,
-		generator.GetTagForTask(generator.TaskName(task.Name()), params...),
-	)
-	if err != nil {
-		return err
-	}
-
 	gs.SetFieldGenerationFunction(
 		field,
-		core.NewFunctionHolderNoArgs(task.GenerationFunction(*taskProperties)),
+		core.NewFunctionHolderNoArgs(
+			taskInstance.GenerationFunction(),
+		),
 	)
+
 	return nil
 }
 
@@ -334,15 +328,15 @@ func (gs *DStructGeneratedStruct[T]) generateFields() {
 }
 
 func (gs *DStructGeneratedStruct[T]) addCustomTypes() {
-	gs.addCustomType(
+	gs.AddCustomType(
 		CustomType{
 			time.Time{},
 			core.DefaultDateFunctionHolder(gs.structConfig.GenerationConfig.Date()),
 		},
 	)
 }
 
-func (gs *DStructGeneratedStruct[T]) addCustomType(customType CustomType) {
+func (gs *DStructGeneratedStruct[T]) AddCustomType(customType CustomType) {
 	// TODO: restrict some types from being added such as nil, ints etc
 	gs.customTypes[reflect.TypeOf(customType.Value).String()] = customType.FunctionHolder
 	// the function holder kind is the find that the function retrusn which could either be an existing kind or a new kind i.ie time.Time would be a new kind
@@ -368,23 +362,6 @@ func (gs *DStructGeneratedStruct[T]) populateGeneratedFields(node *Node[StructFi
 		if gs.fieldContexts[field.data.qualifiedName] != nil {
 			continue
 		}
-		// fmt.Println(
-		// 	"Field: ",
-		// 	field.data.qualifiedName,
-		// 	field.data.value.Kind(),
-		// 	field.data.ptrDepth,
-		// 	field.data.ptrKind,
-		// 	field.data.IsFieldDereferencable(),
-		// )
-
-		// fmt.Println(
-		// 	"POP: ",
-		// 	field.data.qualifiedName,
-		// 	gs.customTypes,
-		// 	field.data.goType,
-		// 	field.data.dstructType,
-
-		// )
 
 		if customType := gs.customTypes[field.data.goType]; customType != nil {
 			gs.fieldContexts[field.data.qualifiedName] = core.NewGeneratedFieldContext(

examples/task/main.go

@@ -12,83 +12,77 @@ import (
 )
 
 const (
-	GenInt32 generator.TaskName = "GenInt32"
+	GenInt32 string = "GenInt32"
 )
 
 type genInt32Params struct {
 	min int32
 	max int32
 }
 
-type GenInt32Task struct{}
-
-// Ensure GenInt32Task implements Task.
-var _ generator.Task = &GenInt32Task{}
+type GenInt32Task struct {
+	generator.BaseTask
+	numberConfig config.NumberRangeConfig
+}
 
-// Tags implements Task.
-func (g *GenInt32Task) Name() string {
-	return string(GenInt32)
+type GenInt32TaskInstance struct {
+	GenInt32Task
+	genFunc generator.GenerationFunction
 }
 
-// GenerationFunction implements Task.
-func (g *GenInt32Task) GenerationFunction(
-	taskProperties generator.TaskProperties,
-) generator.GenerationFunction {
-	generator.ValidateParamCount(g, taskProperties)
-	params := g.getInt32Params(taskProperties.FieldName, taskProperties.Parameters)
-	numberConfig := config.NewNumberRangeConfig()
-	numberConfig.Int().SetRange(int(params.min), int(params.max))
-	return core.GenerateNumberFunc[int](numberConfig)
+var (
+	_ generator.TaskInstance = &GenInt32TaskInstance{}
+	// Ensure GenInt32Task implements Task.
+	_ generator.Task = &GenInt32Task{}
+)
+
+func NewGenInt32Task() *GenInt32Task {
+	gt := &GenInt32Task{
+		numberConfig: config.NewNumberRangeConfig(),
+		BaseTask:     *generator.NewBaseTask(string(GenInt32), 2),
+	}
+	return gt
 }
 
-func (g *GenInt32Task) ExpectedParameterCount() int {
-	return 2
+func (g GenInt32Task) Instance(params ...string) generator.TaskInstance {
+	gt := &GenInt32TaskInstance{
+		GenInt32Task: g,
+	}
+	gt.numberConfig = g.numberConfig.Copy()
+	gt.SetParameters(params...)
+	gt.genFunc = core.GenerateNumberFunc[int32](gt.numberConfig)
+	return gt
 }
 
-func (g *GenInt32Task) FunctionHolder(taskProperties generator.TaskProperties) core.FunctionHolder {
-	return core.NewFunctionHolderNoArgs(g.GenerationFunction(taskProperties))
+func (g *GenInt32TaskInstance) GenerationFunction() generator.GenerationFunction {
+	return g.genFunc
 }
 
-func (g *GenInt32Task) getInt32Params(fieldName string, params []string) genInt32Params {
-	param_1, err := strconv.Atoi(params[0])
+func (g *GenInt32TaskInstance) SetParameters(params ...string) {
+	g.ValidateParamCount(params...)
+	min, err := strconv.Atoi(params[0])
 	if err != nil {
-		panic(fmt.Sprintf("error with field %s: task %s error: %s", fieldName, GenInt32, err))
+		panic(fmt.Sprintf("Error parsing min value: %s", err))
 	}
-
-	param_2, err := strconv.Atoi(params[1])
+	max, err := strconv.Atoi(params[1])
 	if err != nil {
-		panic(fmt.Sprintf("error with field %s: task %s error: %s", fieldName, GenInt32, 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", fieldName, GenInt32, err))
-
+		panic(fmt.Sprintf("Error parsing max value: %s", err))
 	}
 
-	return genInt32Params{
-		min: int32(param_1),
-		max: int32(param_2),
+	if min > max {
+		panic(fmt.Sprintf("min value %d is greater than max value %d", min, max))
 	}
+	g.numberConfig.Int32().SetRange(int32(min), int32(max))
 }
 
 type M struct {
 	Name string
 }
 
 type Person struct {
-	// Love ABC
 	Age   *int
 	Time  time.Time
 	Other *M
-
-	// Parray []Person
-
-	// Person *Person
 }
 
 type P struct {
@@ -97,72 +91,20 @@ type P struct {
 }
 
 type Test struct {
-	// A      *int
-	// S      string
-	C      int
-	Person P `json:"person"`
-
+	B      int32 `gen_task:"GenInt32(2)" gen_task_1:"10" gen_task_2:"20"`
+	C      int32
+	Person P
 	Cpoint *int
 	T      time.Time
-
-	// Pa     []Pa
-	// Parray []Person
-
-	// L
 }
 
 func main() {
-	// e := dstruct.ExtendStruct(Test{}).Build().Instance()
-	// createTime := time.Now()
-	// // for i := 0; i < 1; i++ {
-	// // 	estruct.AddField(fmt.Sprintf("Test_%d", i), Test{}, "")
-	// // }
-	// fmt.Println(time.Since(createTime))
-	// // b := estruct.Build()
-	// //
-	// st := config.GenerationSettings{SetNonRequiredFields: true}
-	// gestruct := dstruct.NewGeneratedStructWithConfig(e,
-	// 	config.NewDstructConfig(),
-	// 	st,
-	// )
-	//
-	// c := gestruct.GetGenerationConfig()
-	// c.SetIntRange(20, 50)
-	// st.SetNonRequiredFields = false
-	//
-	// // gestruct.SetFieldGenerationSettings("Person", st)
-	// // gestruct.SetFieldGenerationConfig("Person", c)
-	//
-	// gTime := time.Now()
-	// gestruct.Generate()
-	// // gestruct.Update()
-	// // gestruct.Set("Person.P", Person{Age: new(int), Time: time.Now()})
-	// err := gestruct.Set(
-	// 	"Person.P",
-	// 	Person{Age: new(int), Time: time.Now(), Other: &M{Name: "Martin"}},
-	// )
-	// if err != nil {
-	// 	// panic(err)
-	// }
-	//
-	// fmt.Println("Time to generate: ", time.Since(gTime))
-	// fmt.Printf("%+v\n", gestruct.Get_("Person.P.Other.Name"))
-	// for field := range gestruct.GetFields() {
-	// fmt.Println("Field: ", field)
-	// fmt.Printf(
-	// 	"'%s': dstruct: %+v  goType: %+v\n",
-	// 	field,
-	// 	value.GetDstructType(),
-	// 	value.GetGoType(),
-	// )
-	// }
-
 	generatedStuct := dstruct.NewGeneratedStructWithConfig(
 		Test{Cpoint: new(int)},
 		config.NewDstructConfig().SetSliceLength(3, 3),
 		config.DefaultGenerationSettings(),
 	)
-	gt := &GenInt32Task{}
+	gt := NewGenInt32Task()
 	generator.AddTask(gt)
 	if err := generatedStuct.Set("Person.P", Person{}); err != nil {
 		panic(err)
@@ -171,12 +113,14 @@ func main() {
 		"Person.Value",
 		config.NewDstructConfig().SetIntRange(800, 1000),
 	)
-
-	generatedStuct.SetFieldFromTask("C", gt, 300, 400)
-	// generatedStuct.Update()
+	gti := gt.Instance("20", "30").(*GenInt32TaskInstance)
+	generatedStuct.SetFieldFromTaskInstance("C", gti)
 	generatedStuct.Generate()
 
 	fmt.Printf("%+v\n", generatedStuct)
+	gti.SetParameters("100", "200")
 
-	fmt.Println("Testing task")
+	generatedStuct.Generate()
+
+	fmt.Printf("%+v\n", generatedStuct)
 }

generated.struct.go

@@ -72,6 +72,12 @@ type GeneratedStruct interface {
 	// SetGenerationFunctions sets the generation functions for the struct and propagates the settings to all fields
 	SetGenerationFunctions(functions core.DefaultGenerationFunctions)
 
-	// SetFieldFromTask sets the field value from the task. The task is used to generate the value for the field.
-	SetFieldFromTask(field string, task generator.Task, params ...any) error
+	// SetFieldFromTaskInstance sets the field value from the task instance. The task is used to generate the value for the field.
+	SetFieldFromTaskInstance(
+		field string,
+		taskInstance generator.TaskInstance,
+	) error
+
+	// AddCustomType adds a custom type to the struct. The custom type is used to generate values for fields of the custom type.
+	AddCustomType(customType CustomType)
 }

generator/base.task.go

@@ -0,0 +1,48 @@
+package generator
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type BaseTask struct {
+	taskName       string
+	parameterCount int
+}
+
+func NewBaseTask(taskName string, parameterCount int) *BaseTask {
+	return &BaseTask{
+		taskName:       taskName,
+		parameterCount: parameterCount,
+	}
+}
+
+func (b *BaseTask) ParameterCount() int {
+	return b.parameterCount
+}
+
+func (b *BaseTask) GetTags(params ...string) reflect.StructTag {
+	b.ValidateParamCount(params...)
+	tags := fmt.Sprintf(`gen_task:"%s(%d)"`, b.taskName, len(params))
+	for i, p := range params {
+		tags += fmt.Sprintf(` gen_task_%d:"%v"`, (i + 1), p)
+	}
+	return reflect.StructTag(tags)
+}
+
+func (b *BaseTask) Name() string {
+	return b.taskName
+}
+
+func (b *BaseTask) ValidateParamCount(params ...string) {
+	if len(params) != b.parameterCount && b.parameterCount != -1 {
+		panic(
+			fmt.Sprintf(
+				"error with task '%s': task requires %d parameters but has %d",
+				b.taskName,
+				b.parameterCount,
+				len(params),
+			),
+		)
+	}
+}

generator/core/generated.field.go

@@ -286,15 +286,17 @@ func (field *GeneratedField) getGenerationFunction() generator.GenerationFunctio
 
 	_, ok = tags.Lookup("gen_task")
 	if ok {
-		taskProperties, err := generator.CreateTaskProperties(field.Name, tags)
+
+		taskProperties, err := generator.CreateTaskPropertiesFromTag(tags)
 		if err != nil {
-			panic(fmt.Sprintf("Error decoding gen_task: %s", err.Error()))
+			panic(fmt.Sprintf("Error decoding gen_task for '%s': %s", field.Name, err.Error()))
 		}
 		task := generator.GetTask(taskProperties.TaskName)
 		if task == nil {
 			panic(fmt.Sprintf("Unregistered task %s", taskProperties.TaskName))
 		}
-		return task.GenerationFunction(*taskProperties)
+		return task.Instance(taskProperties.Parameters()...).GenerationFunction()
+
 	}
 
 	// if we get no match, we default to the default generation function for the kind

generator/core/no.arg.function.holder.go

@@ -19,6 +19,9 @@ func NewFunctionHolderNoArgs(
 	return &FunctionHolderWithNoArgs{
 		BaseFunctionHolder: BaseFunctionHolder{
 			generationFunction: generationFunction,
+			resetFunction: func(cfg config.Config) generator.GenerationFunction {
+				return generationFunction
+			},
 		},
 	}
 }