Clean up

- Use lower snake_case file names to follow go design...
- Move parts of the container instance handling to their own files, that ~700 line file just doesn't cut it for me
- Move tests into ./tests to keep things cleaner/tests more specific(due to our file naming)
- Test files for different parts of container logic
- Rename package to "container"
- Rename "IocContainer" struct to "ContainerInstance"... need better name still... wanted to use "Container", but the global container is named "Container".
- Renamed "IocContainerConfig" to "ContainerConfig"
- Renamed "IocContainerBinding" to "Binding"

Author: iDevelopThings

Container.go

@@ -1,8 +1,8 @@
-package Container
+package container
 
 import "reflect"
 
-type IocContainerBinding struct {
+type Binding struct {
 	// Function, Concrete, Abstract
 	// Function is a function we call to get a resolved value
 	// Concrete is resolvable by passing a type of the concrete

Container_test.go

@@ -0,0 +1,79 @@
+package container
+
+import (
+	"log"
+	"reflect"
+)
+
+// addFunctionBinding - Create a new container binding from the function
+// This resolves the return type of the function as the Abstract
+// And the functions return value is our Concrete
+func (container *ContainerInstance) addFunctionBinding(definition reflect.Type, resolver any) {
+	numOut := definition.NumOut()
+	if numOut == 0 {
+		log.Printf("Trying to register binding but it doesnt have a return type...")
+		return
+	}
+	if numOut > 1 {
+		log.Printf("Registering a function binding with > 1 return args. Only the first arg is handled.")
+	}
+
+	// if definition.NumIn() > 0 {
+	// 	log.Printf("Function binding has args... if these args cannot be found in the container when resolving, your code will error.")
+	// }
+
+	resolverType := reflect.TypeOf(resolver)
+
+	container.addBinding(indirectType(definition.Out(0)), &Binding{
+		bindingType: "Function",
+
+		resolverFunction:   resolver,
+		isFunctionResolver: true,
+
+		abstractType: definition,
+		concreteType: resolverType,
+
+		invocable: CreateInvocableFunction(resolver),
+	})
+}
+
+// addConcreteBinding - Create a new container binding from the concrete value
+// This will set our abstract type to the concrete type and the concrete type will be our concrete type..
+// This just allows us to easily bind things to the container if we don't care about abstracts
+func (container *ContainerInstance) addConcreteBinding(definition reflect.Type, concrete any) {
+	concreteType := definition
+	if definition.Kind() == reflect.Ptr {
+		concreteType = definition.Elem()
+	}
+
+	// concreteWrapperFuncType := reflect.TypeOf(func() any {
+	// 	return concrete
+	// })
+	//
+	// concreteFunc := reflect.MakeFunc(concreteWrapperFuncType, func(args []reflect.Value) []reflect.Value {
+	// 	return []reflect.Value{reflect.ValueOf(concrete)}
+	// })
+
+	container.addBinding(concreteType, &Binding{
+		bindingType: "Concrete",
+
+		isFunctionResolver: false,
+
+		abstractType: concreteType,
+		concreteType: definition,
+
+		invocable: CreateInvocable(concreteType),
+	})
+}
+
+// addBinding - Convenience function to add a Binding for the type &
+// create a reverse lookup for Concrete -> Abstract
+func (container *ContainerInstance) addBinding(abstractType reflect.Type, binding *Binding) {
+	container.bindings[abstractType] = binding
+	container.concretes[binding.concreteType] = abstractType
+}
+
+func (container *ContainerInstance) addSingletonBinding(singletonType reflect.Type, binding *Binding) {
+	binding.isSingleton = true
+	container.addBinding(singletonType, binding)
+}

ContainerBinding.go binding.go

@@ -0,0 +1,85 @@
+package container
+
+import (
+	"log"
+	"reflect"
+	"unsafe"
+)
+
+// hasBinding - Look up a Type in the container and return whether it exists
+func (container *ContainerInstance) hasBinding(binding reflect.Type) bool {
+	_, ok := container.bindings[binding]
+
+	return ok
+}
+
+// getBindingType - Try to get a binding type from the binding arg in a few different ways
+// We'll first assume we're checking for an abstract type binding...
+// If we didn't get it from the abstract, we'll then check for the concrete...
+// Now as a last ditch effort, we'll look the bindingType up in container.concretes
+// If we can't find anything, we return nil
+func (container *ContainerInstance) getBindingType(binding any) reflect.Type {
+	bindingType := getType(binding)
+
+	// First, we'll check if we have this type as a singleton binding
+	testType := getConcreteReturnType(bindingType)
+	if container.hasBinding(testType) {
+		return testType
+	}
+
+	// We'll first assume we're checking for an abstract type binding...
+	testType = getAbstractReturnType(bindingType)
+	if container.hasBinding(testType) {
+		return testType
+	}
+
+	// If we didn't get it from the abstract, we'll then check for the concrete...
+	testType = getConcreteReturnType(bindingType)
+	if container.hasBinding(testType) {
+		return testType
+	}
+
+	// Now as a last ditch effort, we'll look the bindingType up in container.concretes
+	if potentialAbstract, ok := container.concretes[bindingType]; ok {
+		if container.hasBinding(potentialAbstract) {
+			return potentialAbstract
+		}
+	}
+
+	return nil
+}
+
+// makeFromBinding - Once we've obtained our binding type from
+// Make, we'll then check the containers bindings
+// If it doesn't exist, and we have a parent container we'll then call makeFromBinding on the
+// parent container. Which will either recurse until a resolve is made, or return nil
+func (container *ContainerInstance) makeFromBinding(binding reflect.Type, parameters ...any) any {
+	containerBinding, ok := container.bindings[binding]
+	if !ok {
+		if container.parent != nil {
+			return container.parent.makeFromBinding(binding, parameters...)
+		}
+		log.Printf("Failed to resolve container binding for abstract type %s", binding.String())
+		return nil
+	}
+
+	return container.resolve(containerBinding, parameters...)
+}
+
+func (container *ContainerInstance) pointer() unsafe.Pointer {
+	return reflect.ValueOf(container).UnsafePointer()
+}
+
+func removeAllChildContainerInstances() {
+	// mainContainerPointer := Container.pointer()
+	//
+	// newContainerInstances := []unsafe.Pointer{}
+	//
+	// for _, containerPtr := range containerInstances {
+	// 	var container = *((*ContainerInstance)(containerPtr))
+	//
+	// 	if container.parent == nil && container.pointer() != mainContainerPointer {
+	//
+	// 	}
+	// }
+}

container_binding_creators.go

@@ -0,0 +1,38 @@
+package container
+
+// func (container *ContainerInstance) binding(abstract any) *Binding {
+// 	binding := container.getBindingType(abstract)
+//
+// 	if binding == nil {
+// 		log.Printf("Failed to resolve binding for abstract type %s", reflect.TypeOf(abstract).String())
+// 		return nil
+// 	}
+//
+// 	containerBinding, ok := container.bindings[binding]
+//
+// 	if ok {
+// 		return containerBinding
+// 	}
+//
+// 	if container.parent != nil {
+// 		return container.parent.Binding(abstract)
+// 	}
+//
+// 	log.Printf("Failed to resolve container binding for abstract type %s", binding.String())
+// 	return nil
+// }
+
+// Call - Call the specified function via the container, you can add parameters to your function,
+// and they will be resolved from the container, if they're registered
+func (container *ContainerInstance) Call(function any, parameters ...any) []any {
+	invocable := CreateInvocableFunction(function)
+
+	instanceReturnValues := invocable.CallMethodWith(container, parameters...)
+
+	returnResult := make([]any, len(instanceReturnValues))
+	for i, value := range instanceReturnValues {
+		returnResult[i] = value.Interface()
+	}
+
+	return returnResult
+}

container_helpers.go

@@ -1,4 +1,4 @@
-package Container
+package container
 
 import (
 	"reflect"
@@ -7,25 +7,26 @@ import (
 	"golang.org/x/exp/maps"
 )
 
-// IocContainerConfig - Holds configuration values... soon I will add some more, make them work fully
+// ContainerConfig - Holds configuration values... soon I will add some more, make them work fully
 // Right now this is a placeholder
-type IocContainerConfig struct {
+type ContainerConfig struct {
 	OnlyInjectStructFieldsWithInjectTag bool
 }
 
-type IocContainer struct {
-	Config *IocContainerConfig
+// ContainerInstance - Holds all of our container registration
+type ContainerInstance struct {
+	Config *ContainerConfig
 
 	// Store our singleton instances
-	// instances map[reflect.Type]*IocContainerBinding
+	// instances map[reflect.Type]*Binding
 
 	// Our resolved singleton instances
 	resolved map[reflect.Type]any
 
 	// Store our abstract -> concrete bindings
 	// If a type doesn't have an abstract type
 	// We'll store concrete -> concrete
-	bindings map[reflect.Type]*IocContainerBinding
+	bindings map[reflect.Type]*Binding
 
 	// Store aliases of Concrete -> Abstract, so we can resolve from concrete
 	// when we only bound Abstract -> Concrete
@@ -36,16 +37,16 @@ type IocContainer struct {
 	tagged map[string][]reflect.Type
 
 	// If our container is a child container, we'll have a pointer to our parent
-	parent *IocContainer
+	parent *ContainerInstance
 }
 
 // CreateContainer - Create a new container instance
-func CreateContainer() *IocContainer {
-	c := &IocContainer{
-		Config: &IocContainerConfig{OnlyInjectStructFieldsWithInjectTag: false},
+func CreateContainer() *ContainerInstance {
+	c := &ContainerInstance{
+		Config: &ContainerConfig{OnlyInjectStructFieldsWithInjectTag: false},
 
 		resolved:  make(map[reflect.Type]any),
-		bindings:  make(map[reflect.Type]*IocContainerBinding),
+		bindings:  make(map[reflect.Type]*Binding),
 		concretes: make(map[reflect.Type]reflect.Type),
 		tagged:    make(map[string][]reflect.Type),
 	}
@@ -60,11 +61,11 @@ var containerInstances = []unsafe.Pointer{}
 
 // CreateChildContainer - Returns a new container, any failed look-ups of our
 // child container, will then be looked up in the parent, or returned nil
-func (container *IocContainer) CreateChildContainer() *IocContainer {
-	c := &IocContainer{
-		Config:    &IocContainerConfig{OnlyInjectStructFieldsWithInjectTag: false},
+func (container *ContainerInstance) CreateChildContainer() *ContainerInstance {
+	c := &ContainerInstance{
+		Config:    &ContainerConfig{OnlyInjectStructFieldsWithInjectTag: false},
 		resolved:  make(map[reflect.Type]any),
-		bindings:  make(map[reflect.Type]*IocContainerBinding),
+		bindings:  make(map[reflect.Type]*Binding),
 		concretes: make(map[reflect.Type]reflect.Type),
 		tagged:    make(map[string][]reflect.Type),
 	}
@@ -78,19 +79,21 @@ func (container *IocContainer) CreateChildContainer() *IocContainer {
 
 // ClearInstances - This will just remove any singleton instances from the container
 // When they are next resolved via Make/MakeTo, they will be instantiated again
-func (container *IocContainer) ClearInstances() {
+func (container *ContainerInstance) ClearInstances() {
 	maps.Clear(container.resolved)
 }
 
 // Reset - Reset will empty all bindings in this container, you will have to register
 // any bindings again before you can resolve them.
-func (container *IocContainer) Reset() {
+func (container *ContainerInstance) Reset() {
 	maps.Clear(container.resolved)
 	maps.Clear(container.bindings)
 	maps.Clear(container.concretes)
+	maps.Clear(container.tagged)
+	container.parent = nil
 }
 
 // ParentContainer - Returns the parent container, if one exists
-func (container *IocContainer) ParentContainer() *IocContainer {
+func (container *ContainerInstance) ParentContainer() *ContainerInstance {
 	return container.parent
 }