expose ResolveFunctionArgsWithInterceptor and ResolveFunctionArgs

Add "Interceptor" ability to ResolveFunctionArgs by calling ResolveFunctionArgsWithInterceptor

This allows for us to define a function which we can over-ride certain args during the resolution of them...

This is mainly for use with Invocables... which has a new method: CallMethodByNameWithArgInterceptor
where we can define one. See the tests for a gross example

Author: iDevelopThings

container_resolver.go

@@ -74,24 +74,17 @@ func (container *ContainerInstance) resolveStructFields(instanceType reflect.Typ
 	return instance
 }
 
-// resolveFunctionArgs - Resolves the args of our function we bound to the container
-// parameters is an array of values that we wish to provide which is optional
-// parameters will first be assigned starting at index 0 of the functions args
-// Then we'll look at the function args, and if we assigned a value from the parameters already
-// it will use that, otherwise we'll look the type up in the container and resolve it
-func (container *ContainerInstance) resolveFunctionArgs(function reflect.Value, parameters ...any) []reflect.Value {
+type FuncArgResolverInterceptor = func(index int, argType reflect.Type, typeZeroVal reflect.Value) (reflect.Value, bool)
+
+func (container *ContainerInstance) ResolveFunctionArgsWithInterceptor(function reflect.Value, interceptor FuncArgResolverInterceptor, parameters ...any) []reflect.Value {
 	inArgCount := 0
 
 	if !function.IsValid() || function.IsZero() {
 		return []reflect.Value{}
 	}
 
-	functionType := function.Type()
-	if functionType.Kind() == reflect.Ptr {
-		inArgCount = functionType.Elem().NumIn()
-	} else {
-		inArgCount = functionType.NumIn()
-	}
+	functionType := getType(function)
+	inArgCount = functionType.NumIn()
 
 	// We'll put the types of all in args into this array,
 	// so we don't have to keep running .In()
@@ -118,24 +111,36 @@ func (container *ContainerInstance) resolveFunctionArgs(function reflect.Value,
 
 	// Assign parameter values from the provided parameters list first
 	if len(parameters) > 0 {
-		for i := 0; i < len(parameters); i++ {
-			paramVal := reflect.ValueOf(parameters[i])
+		parametersType := reflect.TypeOf(parameters)
+
+		// We can provide a function as an "interceptor" instead...
+		if parametersType.Kind() == reflect.Array || parametersType.Kind() == reflect.Slice {
+			for i := 0; i < len(parameters); i++ {
+				paramVal := reflect.ValueOf(parameters[i])
+
+				// We'll only assign the param from the provided list, if the type matches?
+				inArg := inArgTypes[i]
+				if inArg == paramVal.Type() {
+					assignArg(i, paramVal)
+				}
+			}
 
-			// We'll only assign the param from the provided list, if the type matches?
-			inArg := inArgTypes[i]
-			if inArg == paramVal.Type() {
-				assignArg(i, paramVal)
+			// If our provided parameters fulfils all the function args, let's just early return
+			if assignedCount >= inArgCount {
+				return args
 			}
 		}
 
-		// If our provided parameters fulfils all the function args, let's just early return
-		if assignedCount >= inArgCount {
-			return args
-		}
 	}
 
 	// Now we'll try to resolve any other types from the container
 	for i := 0; i < inArgCount; i++ {
+		interceptedVal, didIntercept := interceptor(i, inArgTypes[i], args[i])
+		if didIntercept {
+			assignArg(i, interceptedVal)
+			continue
+		}
+
 		// We already assigned it, let's skip...
 		if assignedArgs[i] {
 			continue
@@ -153,9 +158,22 @@ func (container *ContainerInstance) resolveFunctionArgs(function reflect.Value,
 	}
 
 	return args
+
+}
+
+// ResolveFunctionArgs - Resolves the args of our function we bound to the container
+// parameters is an array of values that we wish to provide which is optional
+// parameters will first be assigned starting at index 0 of the functions args
+// Then we'll look at the function args, and if we assigned a value from the parameters already
+// it will use that, otherwise we'll look the type up in the container and resolve it
+func (container *ContainerInstance) ResolveFunctionArgs(function reflect.Value, parameters ...any) []reflect.Value {
+	interceptor := func(index int, argType reflect.Type, typeZeroVal reflect.Value) (reflect.Value, bool) {
+		return typeZeroVal, false
+	}
+	return container.ResolveFunctionArgsWithInterceptor(function, interceptor, parameters...)
 }
 
-// resolveFunctionArg - Used in resolveFunctionArgs, we pass an arg type and attempt to
+// resolveFunctionArg - Used in ResolveFunctionArgs, we pass an arg type and attempt to
 // resolve it from the container, if the type doesn't exist in the container
 // we'll return a zero value version of the type
 func (container *ContainerInstance) resolveFunctionArg(arg reflect.Type) (reflect.Value, bool) {

invocable.go

@@ -123,7 +123,21 @@ func (invocable *Invocable) CallMethodByNameWith(methodName string, container *C
 	structInstance := invocable.InstantiateStructAndFill(container)
 	method := structInstance.MethodByName(methodName)
 
-	return method.Call(container.resolveFunctionArgs(method, parameters...))
+	return method.Call(container.ResolveFunctionArgs(method, parameters...))
+}
+
+func (invocable *Invocable) CallMethodByNameWithArgInterceptor(methodName string, container *ContainerInstance, interceptor FuncArgResolverInterceptor, parameters ...any) []reflect.Value {
+	if invocable.typeOfBinding != "struct" {
+		panic("CallMethodByNameWith is only usable when the Invocable instance is created with a struct.")
+	}
+	if !invocable.isInstantiated {
+		invocable.instantiate()
+	}
+
+	structInstance := invocable.InstantiateStructAndFill(container)
+	method := structInstance.MethodByName(methodName)
+
+	return method.Call(container.ResolveFunctionArgsWithInterceptor(method, interceptor, parameters...))
 }
 
 // CallMethodWith - Call the method and assign its parameters from the passed parameters & container
@@ -133,6 +147,6 @@ func (invocable *Invocable) CallMethodWith(container *ContainerInstance, paramet
 	}
 
 	return invocable.instance.Call(
-		container.resolveFunctionArgs(invocable.instance, parameters...),
+		container.ResolveFunctionArgs(invocable.instance, parameters...),
 	)
 }

tests/invocable_test.go

@@ -62,3 +62,26 @@ func TestCreatingStructUsingDI(t *testing.T) {
 	}
 
 }
+
+func TestCallingFunctionOnStructUsingArgInterceptor(t *testing.T) {
+	container := Container.CreateContainer()
+	container.Bind(createSingletonServiceOne)
+
+	invocable := Container.CreateInvocableStruct(reflect.ValueOf(&serviceConcrete{}))
+	results := invocable.CallMethodByNameWithArgInterceptor(
+		"InterceptFunc",
+		container,
+		func(index int, argType reflect.Type, typeZeroVal reflect.Value) (reflect.Value, bool) {
+			if argType.Name() == "anotherServiceAbstract" {
+				return reflect.ValueOf(&serviceConcreteTwo{
+					message: "Hi, from interceptor",
+				}), true
+			}
+
+			return typeZeroVal, false
+		},
+	)
+
+	assert.Equal(t, results[0].Interface(), "Hi, from interceptor")
+
+}

tests/mock_objects.go

@@ -30,6 +30,10 @@ func (service *serviceConcrete) Message() string {
 	return "Hello World!"
 }
 
+func (service *serviceConcrete) InterceptFunc(anotherService anotherServiceAbstract) string {
+	return anotherService.Message()
+}
+
 func createSingletonServiceOne() *serviceConcrete {
 	service := new(serviceConcrete)
 	service.message = "TestBindingSingletonValueToContainer"

tests/types_test.go

@@ -1,15 +1,13 @@
 package tests
 
 import (
-	"errors"
 	"testing"
 
 	container "github.com/Envuso/go-ioc-container"
-	"github.com/modern-go/reflect2"
 	"github.com/stretchr/testify/assert"
 )
 
-var pkgPath = "github.com/Envuso/go-ioc-container"
+var pkgPath = "github.com/Envuso/go-ioc-container/tests"
 
 type TestingStr struct {
 	Name string
@@ -31,17 +29,17 @@ func TestTypes_Of(t *testing.T) {
 	assert.Equal(t, pkgPath, testingInter.Path)
 	assert.Equal(t, "TestingInter", testingInter.Name)
 
-	testingErr := container.ContainerTypes.Of(errors.New("yeet"))
-	assert.Equal(t, pkgPath+"/TestingInter", testingErr.FullName)
-	assert.Equal(t, pkgPath, testingErr.Path)
-	assert.Equal(t, "TestingInter", testingErr.Name)
-
-	test := reflect2.TypeByName("container.TestingStr")
-	test.String()
-
-	test2 := reflect2.TypeByPackageName("github.com/Envuso/go-ioc-container", "TestingStr")
-	test2.String()
-	print("")
+	// testingErr := container.ContainerTypes.Of(errors.New("yeet"))
+	// assert.Equal(t, pkgPath+"/TestingInter", testingErr.FullName)
+	// assert.Equal(t, pkgPath, testingErr.Path)
+	// assert.Equal(t, "TestingInter", testingErr.Name)
+
+	// test := reflect2.TypeByName("container.TestingStr")
+	// test.String()
+	//
+	// test2 := reflect2.TypeByPackageName("github.com/Envuso/go-ioc-container", "TestingStr")
+	// test2.String()
+	// print("")
 }
 
 func TestPkgType_Save(t *testing.T) {