Merge pull request #35 from defval/parameter-bag

Parameter bag, improve docs

Author: Maxim Bovtunov

README.md

@@ -23,6 +23,7 @@ You can see latest `v1`
 ## Contents
 
 - [Installing](#installing)
+- [Getting Started](#getting-started)
 - [Tutorial](#tutorial)
   - [Providing](#providing)
   - [Extraction](#extraction)
@@ -31,6 +32,7 @@ You can see latest `v1`
 - [Advanced features](#advanced-features)
   - [Named definitions](#named-definitions)
   - [Optional parameters](#optional-parameters)
+  - [Parameter Bag](#parameter-bag)
   - [Prototypes](#prototypes)
   - [Cleanup](#cleanup)
 - [Contributing](#contributing)
@@ -41,6 +43,10 @@ You can see latest `v1`
 go get -u github.com/defval/inject/v2
 ```
 
+## Getting Started
+
+
+
 ## Tutorial
 
 Let's learn to use `inject` by example. We will code a simple
@@ -342,6 +348,10 @@ type ServiceParameter struct {
 }
 ```
 
+### Parameter Bag
+
+TBD
+
 ### Prototypes
 
 If you want to create a new instance on each extraction use

container.go

@@ -22,7 +22,7 @@ func New(options ...Option) *Container {
 
 // Container is a dependency injection container.
 type Container struct {
-	providers []*providerOptions
+	providers []di.ProvideParams
 	container *di.Container
 }
 
@@ -36,34 +36,26 @@ type Container struct {
 // If the target type does not exist in a container or instance type building failed, Extract() returns an error.
 // Use ExtractOption for modifying the behavior of this function.
 func (c *Container) Extract(target interface{}, options ...ExtractOption) (err error) {
-	var po = &extractOptions{
-		target: target,
+	var params = di.ExtractParams{
+		Target: target,
 	}
 
 	// apply extract options
 	for _, opt := range options {
-		opt.apply(po)
+		opt.apply(&params)
 	}
 
-	return c.container.Extract(di.ExtractParams{
-		Name:   po.name,
-		Target: target,
-	})
+	return c.container.Extract(params)
 }
 
-// Cleanup
+// Cleanup cleanup container.
 func (c *Container) Cleanup() {
 	c.container.Cleanup()
 }
 
 func (c *Container) compile() {
 	for _, po := range c.providers {
-		c.container.Provide(di.ProvideParams{
-			Name:        po.name,
-			Provider:    po.provider,
-			Interfaces:  po.interfaces,
-			IsPrototype: po.prototype,
-		})
+		c.container.Provide(po)
 	}
 
 	c.container.Compile()

di/container.go

@@ -29,27 +29,31 @@ type ProvideParams struct {
 	Name        string
 	Provider    interface{}
 	Interfaces  []interface{}
+	Parameters  ParameterBag
 	IsPrototype bool
 }
 
 // Provide adds constructor into container with parameters.
 func (c *Container) Provide(params ProvideParams) {
-	var provider provider = createConstructor(params.Name, params.Provider)
-	k := provider.resultKey()
+	prov := provider(createConstructor(params.Name, params.Provider))
+	k := prov.resultKey()
 
 	if c.exists(k) {
-		panicf("The `%s` type already exists in container", provider.resultKey())
+		panicf("The `%s` type already exists in container", prov.resultKey())
 	}
 
 	if !params.IsPrototype {
-		provider = asSingleton(provider)
+		prov = asSingleton(prov)
 	}
 
-	c.addProvider(provider)
-	c.provideEmbedParameters(provider)
+	c.addProvider(prov)
+	c.provideEmbedParameters(prov)
+
+	parameterBugProvider := createParameterBugProvider(k, params.Parameters)
+	c.addProvider(parameterBugProvider)
 
 	for _, iface := range params.Interfaces {
-		c.processProviderInterface(provider, iface)
+		c.processProviderInterface(prov, iface)
 	}
 }
 

di/container_test.go

@@ -157,6 +157,7 @@ func TestContainerProvide(t *testing.T) {
 		cleanup := func() {}
 		c.MustProvide(ditest.CreateFooConstructorWithCleanup(cleanup))
 	})
+
 }
 
 func TestContainerExtract(t *testing.T) {
@@ -248,6 +249,50 @@ func TestContainerExtract(t *testing.T) {
 
 		c.MustNotEqualPointer(extracted1, extracted2)
 	})
+
+	t.Run("container extract correct parameter bag for type", func(t *testing.T) {
+		c := NewTestContainer(t)
+
+		c.Provide(di.ProvideParams{
+			Provider: ditest.NewFooWithName,
+			Parameters: di.ParameterBag{
+				"name": "test",
+			},
+		})
+
+		c.MustCompile()
+
+		var foo *ditest.Foo
+		err := c.Extract(di.ExtractParams{
+			Target: &foo,
+		})
+
+		require.NoError(t, err)
+		require.Equal(t, "test", foo.Name)
+	})
+
+	t.Run("container extract correct parameter bag for type", func(t *testing.T) {
+		c := NewTestContainer(t)
+
+		c.Provide(di.ProvideParams{
+			Name:     "named",
+			Provider: ditest.NewFooWithName,
+			Parameters: di.ParameterBag{
+				"name": "test",
+			},
+		})
+
+		c.MustCompile()
+
+		var foo *ditest.Foo
+		err := c.Extract(di.ExtractParams{
+			Name:   "named",
+			Target: &foo,
+		})
+
+		require.NoError(t, err)
+		require.Equal(t, "test", foo.Name)
+	})
 }
 
 func TestContainerResolve(t *testing.T) {

di/internal/ditest/foo.go

@@ -1,13 +1,22 @@
 package ditest
 
+import "github.com/defval/inject/v2/di"
+
 // Foo test struct
-type Foo struct{}
+type Foo struct {
+	Name string
+}
 
 // NewFoo create new foo
 func NewFoo() *Foo {
 	return &Foo{}
 }
 
+// NewFooWithName
+func NewFooWithName(parameters di.ParameterBag) *Foo {
+	return &Foo{Name: parameters.RequireString("name")}
+}
+
 // NewCycleFooBar
 func NewCycleFooBar(bar *Bar) *Foo {
 	return &Foo{}

di/parameter_bag.go

@@ -0,0 +1,26 @@
+package di
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// createParameterBugProvider
+func createParameterBugProvider(key key, parameters ParameterBag) provider {
+	return createConstructor(key.String(), func() ParameterBag { return parameters })
+}
+
+// Parameters
+type ParameterBag map[string]interface{}
+
+// String
+func (b ParameterBag) RequireString(key string) string {
+	value, ok := b[key].(string)
+	if !ok {
+		panic(fmt.Sprintf("value for string key `%s` not found", key))
+	}
+
+	return value
+}
+
+var parameterBagType = reflect.TypeOf(ParameterBag{})

di/provider_ctor.go

@@ -83,9 +83,17 @@ func (c constructorProvider) parameters() parameterList {
 
 	for i := 0; i < c.ctor.NumIn(); i++ {
 		ptype := c.ctor.In(i)
+		var pname string
+
+		if ptype == parameterBagType {
+			pname = c.resultKey().String()
+		}
 
 		p := parameter{
-			key:      key{typ: ptype},
+			key: key{
+				name: pname,
+				typ:  ptype,
+			},
 			optional: false,
 			embed:    isEmbedParameter(ptype),
 		}