🎨 improvements to the di code

pkg/di/README.md

@@ -22,9 +22,8 @@ Exemplo básico:
 
 	func  main() {
 
-	dependencies  := []interface{}{NewFoo}
     app  :=  di.NewContainer()
-    app.AddDependencies(dependencies)
+    app.AddDependencies(NewFoo)
     app.StartApp(InitializeAPP)
     }
 

pkg/di/container.go

@@ -3,6 +3,7 @@ package di
 import (
 	"fmt"
 	"log"
+	"maps"
 	"reflect"
 )
 
@@ -11,21 +12,23 @@ type Container struct {
 }
 
 func NewContainer() Container {
-	return Container{}
+	return Container{
+		dependencies: make(map[string]DependencyBean),
+	}
 }
 
-func (c *Container) AddDependencies(deps []interface{}) {
+func (c *Container) AddDependencies(deps ...interface{}) {
 	// Gera o array com as dependencias
 	ReflectTypeArray := generateDependenciesArray(deps, false)
 	c.checkingNameUnit(ReflectTypeArray)
-	c.dependencies = ReflectTypeArray
+	maps.Copy(c.dependencies, ReflectTypeArray)
 }
 
-func (c *Container) AddGlobalDependencies(deps []interface{}) {
+func (c *Container) AddGlobalDependencies(deps ...interface{}) {
 	// Gera o array com as dependencias
 	ReflectTypeArray := generateDependenciesArray(deps, true)
 	c.checkingNameUnit(ReflectTypeArray)
-	c.dependencies = ReflectTypeArray
+	maps.Copy(c.dependencies, ReflectTypeArray)
 }
 
 func (f *Container) StartApp(startFunc interface{}) {
@@ -50,7 +53,7 @@ func (c *Container) getDependencyConstructorArgs(dependency DependencyBean) []re
 	args := []reflect.Value{}
 	fmt.Printf("constructor: %s, number of parameters: %d\n", dependency.Name, len(dependency.ParamTypes))
 	for position, paramType := range dependency.ParamTypes {
-		
+
 		// Check if trhe variadic param
 		if dependency.IsVariadic {
 			if position == (len(dependency.ParamTypes) - 1) {

pkg/di/examples/main.go

@@ -36,12 +36,10 @@ type Controller struct {
 }
 
 func main() {
-	// Criação de um array de funções de diferentes tipos
-	dependencies := []interface{}{newController, newService, newRepository}
 
 	app := di.NewContainer()
 
-	app.AddDependencies(dependencies)
+	app.AddDependencies(newController, newService, newRepository)
 
 	app.StartApp(InitializeAPP)
 }

pkg/di/tests/basics_test.go

@@ -9,16 +9,12 @@ import (
 
 func Test_Bean_not_found(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{beanInt}
-	a.AddDependencies(funcs)
+	a.AddDependencies(beanInt)
 	assert.Panics(t, func() { a.StartApp(InitializeAPP) })
 }
 
 func Test_Success(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{beanInt, beanFloat32}
-	a.AddDependencies(funcs)
+	a.AddDependencies(beanInt, beanFloat32)
 	assert.NotPanics(t, func() { a.StartApp(InitializeAPP) })
 }

pkg/di/tests/disambiguation_and_interfaces_and_global_test.go

@@ -9,40 +9,29 @@ import (
 
 func Test_Interfaces_Disambiguation_Global_Bean_not_found(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{}
-	a.AddGlobalDependencies(funcs)
 	assert.Panics(t, func() { a.StartApp(NewBarObjectWithoutTag) })
 }
 
 func Test_Interfaces_Disambiguation_Global_Success(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{newFooImplementation1}
-	a.AddGlobalDependencies(funcs)
+	a.AddGlobalDependencies(newFooImplementation1)
 	assert.NotPanics(t, func() { a.StartApp(NewBarObjectWithoutTag) })
 }
 
 func Test_Interfaces_Disambiguation_Global_Tag_not_found(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{newFooImplementation1, newFooImplementation3}
-	a.AddGlobalDependencies(funcs)
+	a.AddGlobalDependencies(newFooImplementation1, newFooImplementation3)
 	assert.Panics(t, func() { a.StartApp(NewBarObjectWithTag) })
 }
 
 func Test_Interfaces_Disambiguation_Global_Not_Tag(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{newFooImplementation1, newFooImplementation2}
-	a.AddGlobalDependencies(funcs)
+	a.AddGlobalDependencies(newFooImplementation1, newFooImplementation2)
 	assert.Panics(t, func() { a.StartApp(NewBarObjectWithoutTag) })
 }
 
 func Test_Interfaces_Disambiguation_Global_Sucess_2(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{newFooImplementation1, newFooImplementation2}
-	a.AddGlobalDependencies(funcs)
+	a.AddGlobalDependencies(newFooImplementation1, newFooImplementation2)
 	assert.NotPanics(t, func() { a.StartApp(NewBarObjectWithTag) })
 }

pkg/di/tests/disambiguation_and_interfaces_test.go

@@ -9,40 +9,29 @@ import (
 
 func Test_Interfaces_Disambiguation_Bean_not_found(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{}
-	a.AddDependencies(funcs)
 	assert.Panics(t, func() { a.StartApp(NewBarObjectWithoutTag) })
 }
 
 func Test_Interfaces_Disambiguation_Success(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{newFooImplementation1}
-	a.AddDependencies(funcs)
+	a.AddDependencies(newFooImplementation1)
 	assert.NotPanics(t, func() { a.StartApp(NewBarObjectWithoutTag) })
 }
 
 func Test_Interfaces_Disambiguation_Tag_not_found(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{newFooImplementation1, newFooImplementation3}
-	a.AddDependencies(funcs)
+	a.AddDependencies(newFooImplementation1, newFooImplementation3)
 	assert.Panics(t, func() { a.StartApp(NewBarObjectWithTag) })
 }
 
 func Test_Interfaces_Disambiguation_Not_Tag(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{newFooImplementation1, newFooImplementation2}
-	a.AddDependencies(funcs)
+	a.AddDependencies(newFooImplementation1, newFooImplementation2)
 	assert.Panics(t, func() { a.StartApp(NewBarObjectWithoutTag) })
 }
 
 func Test_Interfaces_Disambiguation_Sucess_2(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{newFooImplementation1, newFooImplementation2}
-	a.AddDependencies(funcs)
+	a.AddDependencies(newFooImplementation1, newFooImplementation2)
 	assert.NotPanics(t, func() { a.StartApp(NewBarObjectWithTag) })
 }

pkg/di/tests/disambiguation_test.go

@@ -9,40 +9,29 @@ import (
 
 func Test_metadata_Bean_not_found(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{}
-	a.AddDependencies(funcs)
 	assert.Panics(t, func() { a.StartApp(NewBeanWithMetadata) })
 }
 
 func Test_metadata_Success(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{NewBeanDependency1}
-	a.AddDependencies(funcs)
+	a.AddDependencies(NewBeanDependency1)
 	assert.NotPanics(t, func() { a.StartApp(NewBeanWithMetadata) })
 }
 
 func Test_Success_Disambiguation(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{NewBeanDependency1, NewBeanDependency2}
-	a.AddDependencies(funcs)
+	a.AddDependencies(NewBeanDependency1, NewBeanDependency2)
 	assert.NotPanics(t, func() { a.StartApp(NewBeanWithMetadata) })
 }
 
 func Test_Disambiguation_Tag_not_found(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{NewBeanDependency1, NewBeanDependency3}
-	a.AddDependencies(funcs)
+	a.AddDependencies(NewBeanDependency1, NewBeanDependency3)
 	assert.Panics(t, func() { a.StartApp(NewBeanWithMetadata) })
 }
 
 func Test_Disambiguation_Not_Tag(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{NewBeanDependency1, NewBeanDependency2, NewBeanDependency3}
-	a.AddDependencies(funcs)
+	a.AddDependencies(NewBeanDependency1, NewBeanDependency2, NewBeanDependency3)
 	assert.Panics(t, func() { a.StartApp(NewBeanWithoutMetadata) })
 }

pkg/di/tests/duplicate_constructor_test.go

@@ -9,11 +9,9 @@ import (
 
 func Test_Duplicate_constructor(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{beanInt, beanFloat32}
 	assert.Panics(t, func() {
-		a.AddDependencies(funcs)
-		a.AddGlobalDependencies(funcs)
+		a.AddDependencies(beanInt, beanFloat32)
+		a.AddGlobalDependencies(beanInt, beanFloat32)
 		a.StartApp(InitializeAPP)
 	})
 }

pkg/di/tests/global_injection_test.go

@@ -9,16 +9,12 @@ import (
 
 func Test_Global_Injection_Bean_not_found(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{GlobalBeanString, globalBeanInt}
-	a.AddGlobalDependencies(funcs)
+	a.AddGlobalDependencies(GlobalBeanString, globalBeanInt)
 	assert.Panics(t, func() { a.StartApp(GlobalInitializeAPP) })
 }
 
 func Test_Global_Injection_Success(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{globalBeanFloat32, GlobalBeanString, globalBeanInt}
-	a.AddGlobalDependencies(funcs)
+	a.AddGlobalDependencies(globalBeanFloat32, GlobalBeanString, globalBeanInt)
 	assert.NotPanics(t, func() { a.StartApp(GlobalInitializeAPP) })
 }

pkg/di/tests/global_interfaces_test.go

@@ -9,16 +9,11 @@ import (
 
 func Test_global_interfaces_Bean_not_found(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{}
-	a.AddGlobalDependencies(funcs)
 	assert.Panics(t, func() { a.StartApp(NewMyGlobalDependencyObject) })
 }
 
 func Test_global_interfaces_Success(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{newMyGlobalImplementation}
-	a.AddGlobalDependencies(funcs)
+	a.AddGlobalDependencies(newMyGlobalImplementation)
 	assert.NotPanics(t, func() { a.StartApp(NewMyGlobalDependencyObject) })
 }

pkg/di/tests/interfaces_test.go

@@ -9,16 +9,11 @@ import (
 
 func Test_interfaces_Bean_not_found(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{}
-	a.AddDependencies(funcs)
 	assert.Panics(t, func() { a.StartApp(NewMyDependencyObject) })
 }
 
 func Test_interfaces_Success(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{newMyImplementation}
-	a.AddDependencies(funcs)
+	a.AddDependencies(newMyImplementation)
 	assert.NotPanics(t, func() { a.StartApp(NewMyDependencyObject) })
 }

pkg/di/tests/variadic_test.go

@@ -8,28 +8,25 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func newInt2() int{
+func newInt2() int {
 	return 2
 }
 
-func newInt1() int{
+func newInt1() int {
 	return 1
 }
 
-func newStringV() string{
+func newStringV() string {
 	return "stringv"
 }
 
-func NewV(a string, s ...int)string{
+func NewV(a string, s ...int) string {
 	fmt.Println("recebi: ", len(s), " dependencias ")
 	return "s"
 }
 
 func Test_variadic(t *testing.T) {
 	a := di.NewContainer()
-	// Criação de um array de funções de diferentes tipos
-	funcs := []interface{}{newInt1, newInt2, newStringV}
-	a.AddDependencies(funcs)
+	a.AddDependencies(newInt1, newInt2, newStringV)
 	assert.NotPanics(t, func() { a.StartApp(NewV) })
 }
-