First commit.

Author: AlekNS

.gitignore

@@ -0,0 +1,3 @@
+*.out
+
+vendor/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Alexander Sedelnikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,35 @@
+# Go-Inversify - Dependency Injection Tool for Go
+
+Yet another dependency injection system for Go inspired by [InversifyJS](https://github.com/inversify/InversifyJS).
+
+## Installation
+
+#### Go get
+
+```
+go get github.com/alekns/go-inversify
+```
+
+## Examples
+
+#### Values
+
+```
+  container := inversify.Container()
+
+  container.Bind(1).To("Hello")
+  container.Bind(2).To(" world")
+  container.Bind(3).ToFactory(func (word1, word2, optDep Any) Any {
+    return word1.(string) + word2.(string), nil
+  }, 1, 2, inversify.Optional(3))
+
+  // or
+
+  container.Bind(3).ToTypedFactory(func (word1, word2 string, optDep Any) string {
+    // optDep == nil
+    return word1 + word2, nil
+  }, 1, 2, inversify.Optional(3))
+
+  container.IsBound(3) == true
+  container.Get(3).(string) == "Hello world"
+```

auto/method.go

@@ -0,0 +1,2 @@
+package auto
+

auto/reflection.go

@@ -0,0 +1,2 @@
+package auto
+

auto/struct.go

@@ -0,0 +1,2 @@
+package auto
+

binder.go

@@ -0,0 +1,67 @@
+package inversify
+
+import "sync"
+
+// Binding holds factory and dependencies
+type Binding struct {
+	once         sync.Once
+	factory      FactoryFunc
+	dependencies NAny
+}
+
+// To binds to any object that can converted interface{}
+func (b *Binding) To(obj Any) *Binding {
+	b.factory = func() (Any, error) {
+		return obj, nil
+	}
+
+	return b
+}
+
+// ToFactory binds to abstract function with specified dependencies
+func (b *Binding) ToFactory(factoryMethod Any, dependencies ...Any) *Binding {
+	return b.toFactoryMethod(wrapAbstractApplyFuncAsSlice(factoryMethod), dependencies...)
+}
+
+// ToTypedFactory binds to typed function with specified dependencies
+func (b *Binding) ToTypedFactory(factoryMethod Any, dependencies ...Any) *Binding {
+	return b.toFactoryMethod(wrapTypedApplyFuncAsSlice(factoryMethod), dependencies...)
+}
+
+func (b *Binding) toFactoryMethod(factoryMethod func([]Any) (Any, error), dependencies ...Any) *Binding {
+	b.dependencies = dependencies
+	emptyDeps := []Any{}
+	depsCount := len(dependencies)
+
+	b.factory = func() (Any, error) {
+		if depsCount == 0 {
+			return factoryMethod(emptyDeps)
+		}
+		var err error
+		resolvedDeps := make([]Any, depsCount, depsCount)
+		for inx, dep := range b.dependencies {
+			resolvedDeps[inx], err = dep.(FactoryFunc)()
+			if err != nil {
+				return nil, err
+			}
+		}
+		return factoryMethod(resolvedDeps)
+	}
+
+	return b
+}
+
+// InSingletonScope declares dependency as singleton
+func (b *Binding) InSingletonScope() {
+	orig := b.factory
+	var instance Any
+	var err error
+	b.factory = func() (Any, error) {
+		if instance == nil {
+			b.once.Do(func() {
+				instance, err = orig()
+			})
+		}
+		return instance, err
+	}
+}

binder_test.go

@@ -0,0 +1,98 @@
+package inversify
+
+import (
+	"errors"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+)
+
+type BindingTestSuite struct {
+	suite.Suite
+}
+
+func defaultDepVal(val Any) FactoryFunc     { return func() (Any, error) { return val, nil } }
+func defaultDepError(err error) FactoryFunc { return func() (Any, error) { return nil, err } }
+
+func (t *BindingTestSuite) TestBindValue() {
+	binding := &Binding{sync.Once{}, nil, NAny{}}
+
+	binding.To("hello")
+	val, err := binding.factory()
+
+	t.Equal("hello", val)
+	t.NoError(err)
+}
+
+func (t *BindingTestSuite) TestBindAbstractFactory() {
+	binding := &Binding{sync.Once{}, nil, NAny{}}
+
+	binding.ToFactory(func(a, b Any) (Any, error) {
+		return a.(string) + b.(string), nil
+	}, defaultDepVal("1"), defaultDepVal("2"))
+	val, err := binding.factory()
+
+	t.Equal("12", val)
+	t.NoError(err)
+}
+
+func (t *BindingTestSuite) TestBindAbstractFactoryError() {
+	binding := &Binding{sync.Once{}, nil, NAny{}}
+
+	binding.ToFactory(func(a, b Any) (Any, error) {
+		return a.(string) + b.(string), nil
+	}, defaultDepVal("1"), defaultDepError(errors.New("error")))
+	val, err := binding.factory()
+
+	t.Nil(val)
+	t.Error(err)
+}
+
+func (t *BindingTestSuite) TestBindTypedFactory() {
+	binding := &Binding{sync.Once{}, nil, NAny{}}
+
+	counter := 0
+	binding.ToTypedFactory(func(a, b string) (string, error) {
+		counter++
+		return a + b, nil
+	}, defaultDepVal("1"), defaultDepVal("2"))
+	val, err := binding.factory()
+	val, err = binding.factory()
+
+	t.Equal("12", val)
+	t.NoError(err)
+	t.Equal(2, counter)
+}
+
+func (t *BindingTestSuite) TestBindTypedFactorySingleton() {
+	binding := &Binding{sync.Once{}, nil, NAny{}}
+
+	counter := 0
+	binding.ToTypedFactory(func(a, b string) (string, error) {
+		counter++
+		return a + b, nil
+	}, defaultDepVal("1"), defaultDepVal("2")).InSingletonScope()
+	val, err := binding.factory()
+	val, err = binding.factory()
+
+	t.Equal("12", val)
+	t.NoError(err)
+	t.Equal(1, counter)
+}
+
+func (t *BindingTestSuite) TestBindTypedFactoryNoDeps() {
+	binding := &Binding{sync.Once{}, nil, NAny{}}
+
+	binding.ToTypedFactory(func() (string, error) {
+		return "12", nil
+	})
+	val, err := binding.factory()
+
+	t.Equal("12", val)
+	t.NoError(err)
+}
+
+func TestBindingSute(t *testing.T) {
+	suite.Run(t, new(BindingTestSuite))
+}

builder.go

@@ -0,0 +1,27 @@
+package inversify
+
+import "fmt"
+
+func buildContainerImpl(c *containerImpl) {
+	for _, bind := range c.factories {
+		for inx, dep := range bind.dependencies {
+			optdep, hasOpt := dep.(optionalBind)
+			if hasOpt {
+				dep = optdep.dep
+			}
+
+			b, hasDep := c.findFactory(dep)
+			if hasDep {
+				bind.dependencies[inx] = b.factory
+			} else {
+				if hasOpt {
+					bind.dependencies[inx] = FactoryFunc(func() (Any, error) {
+						return nil, nil
+					})
+				} else {
+					panic(fmt.Sprintf("depending %+v not found", dep))
+				}
+			}
+		}
+	}
+}

builder_test.go

@@ -0,0 +1,18 @@
+package inversify
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+)
+
+type FactoryTestSuite struct {
+	suite.Suite
+}
+
+func (t *FactoryTestSuite) TestBasic() {
+}
+
+func TestFactorySute(t *testing.T) {
+	suite.Run(t, new(FactoryTestSuite))
+}

container.go

@@ -0,0 +1,107 @@
+package inversify
+
+// IContainer .
+type IContainer interface {
+	// Bind .
+	Bind(Any) *Binding
+
+	// Get .
+	Get(Any) (Any, error)
+	// IsBound .
+	IsBound(Any) bool
+
+	Build()
+
+	// Merge with another container
+	Merge(IContainer) IContainer
+	// SetParent supports for hierarchical DI systems
+	SetParent(IContainer)
+
+	// Snapshot .
+	// Snapshot() IContainer
+}
+
+type optionalBind struct {
+	dep Any
+}
+
+// Optional .
+func Optional(dep Any) Any {
+	return optionalBind{dep}
+}
+
+type containerImpl struct {
+	parent    *containerImpl
+	factories map[Any]*Binding
+}
+
+func (c *containerImpl) Bind(symbol Any) *Binding {
+	b := &Binding{}
+	c.factories[symbol] = b
+	return b
+}
+
+func (c *containerImpl) findFactory(symbol Any) (*Binding, bool) {
+	factory, ok := c.factories[symbol]
+
+	if !ok {
+		if c.parent != nil {
+			return c.parent.findFactory(symbol)
+		}
+
+		return nil, false
+	}
+
+	return factory, true
+}
+
+func (c *containerImpl) Build() {
+	buildContainerImpl(c)
+}
+
+func (c *containerImpl) Get(symbol Any) (Any, error) {
+	return c.factories[symbol].factory()
+}
+
+func (c *containerImpl) IsBound(symbol Any) bool {
+	_, ok := c.factories[symbol]
+	return ok
+}
+
+func (c *containerImpl) Merge(other IContainer) IContainer {
+	container := newContainer()
+
+	otherImpl, ok := other.(*containerImpl)
+	if !ok {
+		panic("container is not containerImpl")
+	}
+
+	for symbol, factory := range c.factories {
+		container.factories[symbol] = factory
+	}
+
+	for symbol, factory := range otherImpl.factories {
+		container.factories[symbol] = factory
+	}
+
+	return container
+}
+
+func (c *containerImpl) SetParent(parent IContainer) {
+	parentImpl, ok := parent.(*containerImpl)
+	if !ok {
+		panic("container is not containerImpl")
+	}
+
+	c.parent = parentImpl
+}
+
+func newContainer() *containerImpl {
+	return &containerImpl{
+		factories: make(map[Any]*Binding),
+	}
+}
+
+func Container() IContainer {
+	return newContainer()
+}