Phase one: Autowire

Author: FilipVPetrov

.gitignore

@@ -0,0 +1,16 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+.idea/

atesting/testing.go

@@ -0,0 +1,51 @@
+package atesting
+
+import (
+	"autowire"
+	"container/list"
+	"log"
+	"reflect"
+)
+
+func Spy(v interface{}, dependency interface{}) {
+	slice := []interface{}{dependency}
+	Spies(v, slice)
+}
+
+func Spies(v interface{}, dependencies []interface{}) {
+	queue := list.New()
+	queue.PushBack(v)
+	for queue.Len() > 0 {
+		elemQueue := queue.Front()
+		value := reflect.ValueOf(elemQueue.Value)
+		queue.Remove(elemQueue)
+		log.Printf("+++ %+v", value)
+		var elem reflect.Value
+		switch value.Kind() {
+		case reflect.Ptr:
+			elem = value.Elem()
+		case reflect.Struct:
+			elem = value
+		}
+		for i := 0; i < elem.NumField(); i++ {
+			field := elem.Type().Field(i)
+			log.Printf("[%s] %s:%+v", field.Type.String(), field.Name, elem.Field(i))
+			tag, ok := field.Tag.Lookup(autowire.Tag)
+			if ok {
+				if tag != "" {
+					for _, dependency := range dependencies {
+						dependValue := reflect.ValueOf(dependency)
+						if dependValue.Type().Implements(field.Type) {
+							t := reflect.New(dependValue.Type())
+							log.Println("found dependency by tag " + tag + " will be used " + t.Type().String())
+							elem.Field(i).Set(reflect.ValueOf(dependency))
+						}
+					}
+				}
+				if !elem.Field(i).IsNil() {
+					queue.PushBack(elem.Field(i).Elem().Interface())
+				}
+			}
+		}
+	}
+}

autowire.go

@@ -0,0 +1,144 @@
+package autowire
+
+import (
+	"log"
+	"os"
+	"os/signal"
+	"reflect"
+	"regexp"
+	"strings"
+)
+
+var dependencies map[string]interface{}
+var currentProfile = getProfile()
+var ch = make(chan os.Signal)
+
+const Tag = "autowire"
+
+func init() {
+	log.SetFlags(log.LstdFlags | log.Lshortfile)
+	log.Println("Init Autowire Context")
+	signal.Notify(ch, os.Interrupt, os.Kill)
+
+	dependencies = make(map[string]interface{})
+}
+
+func RunOmitTest(f func()) {
+	if currentProfile != _Testing {
+		f()
+	}
+}
+
+func Autowire(v interface{}) {
+	value := reflect.ValueOf(v)
+	switch value.Kind() {
+	case reflect.Invalid:
+		log.Println("invalid reflection type")
+	case reflect.Ptr:
+		structType := getStructPtrFullPath(value)
+		_, ok := dependencies[structType]
+		if ok {
+			log.Printf("%s already autowired. Going go overwrite it`s value!", structType)
+		} else {
+			autowireDependencies(value)
+			dependencies[structType] = v
+		}
+	default: // reflect.Array, reflect.Struct, reflect.Interface
+		log.Println(value.Type().String() + " value")
+	}
+	log.Println(dependencies)
+}
+
+func Autowired(v interface{}) interface{} {
+	value := reflect.ValueOf(v)
+	var path string
+	switch value.Kind() {
+	case reflect.Invalid:
+		log.Println("invalid")
+	case reflect.Struct:
+		path = getFullPath(value.Type().PkgPath(), value.Type().String())
+	case reflect.Ptr:
+		path = getStructPtrFullPath(value)
+	default:
+		log.Panicln("Unknown Autowired Typed!")
+	}
+	log.Println(path)
+	dependency, ok := dependencies[path]
+	if ok {
+		return dependency
+	}
+	return nil
+}
+
+func getStructPtrFullPath(value reflect.Value) string {
+	return getFullPath(value.Elem().Type().PkgPath(), value.Type().String())
+}
+
+func getFullPath(pkgPath string, typePath string) string {
+	var re = regexp.MustCompile(`^\*?.+\.`)
+	return pkgPath + re.ReplaceAllString(typePath, "/")
+}
+
+func autowireDependencies(value reflect.Value) {
+	elem := value.Elem()
+	for i := 0; i < elem.NumField(); i++ {
+		field := elem.Type().Field(i)
+		tag, ok := field.Tag.Lookup(Tag)
+		if ok {
+			var t reflect.Value
+			log.Println("......." + field.Type.String())
+			if tag != "" {
+				log.Printf("field type: %v\n", getFullPath(field.Type.PkgPath(), field.Type.String()))
+				currentDep := findDependency(tag)
+				if len(currentDep) == 0 {
+					msg := "Unknown dependency " + tag + " found none"
+					if currentProfile != _Testing {
+						log.Panicln(msg)
+					} else {
+						log.Println(msg)
+					}
+				} else {
+					v := reflect.ValueOf(currentDep[0])
+					if v.Type().Implements(field.Type) {
+						t = reflect.New(v.Type())
+						log.Println("found dependency by tag " + tag + " will be used " + t.Type().String())
+						elem.Field(i).Set(reflect.ValueOf(currentDep[0]))
+					} else {
+						log.Panicln(v.Type().String() + " doesnt Implements: " + field.Type.String())
+					}
+				}
+			} else {
+				t = reflect.New(elem.Type().Field(i).Type.Elem())
+				log.Printf("field type: %v", getStructPtrFullPath(t))
+				dependency, found := dependencies[getStructPtrFullPath(t)]
+				if found {
+					elem.Field(i).Set(reflect.ValueOf(dependency))
+				}
+			}
+		}
+	}
+}
+
+func findDependency(tagDependencyType string) []interface{} {
+	var result []interface{}
+	for tmp, dep := range dependencies {
+		if strings.Contains(tmp, tagDependencyType) {
+			result = append(result, dep)
+		}
+	}
+	return result
+}
+
+type AutoClosable interface {
+	Close()
+}
+
+func Run(mainFunction func()) {
+	defer close()
+	mainFunction()
+}
+
+func close() {
+	println("HEREE")
+
+}

example_application/autowire_test.go

@@ -0,0 +1,30 @@
+package example_application
+
+import (
+	"autowire"
+	"autowire/atesting"
+	"autowire/example_application/service"
+	"log"
+	"testing"
+)
+
+type FilipPaymentServiceTest struct {
+}
+
+func (FilipPaymentServiceTest) Status() {
+	log.Println("FilipPaymentServiceTest...")
+}
+
+type TestClient struct {
+	T string
+}
+
+func (TestClient) Connect() {
+	log.Println("TestConnected")
+}
+
+func TestAutowire(t *testing.T) {
+	var service = autowire.Autowired(service.UserService{}).(*service.UserService)
+	atesting.Spies(service, []interface{}{&FilipPaymentServiceTest{}, &TestClient{T: "filip"}})
+	log.Println(service.Do())
+}

example_application/configuration/application_config.go

@@ -0,0 +1,23 @@
+package configuration
+
+import (
+	"autowire"
+	"log"
+)
+
+func init() {
+	log.Println("Initializing ApplicationConfig")
+	autowire.Autowire(New("con"))
+}
+
+type ApplicationConfig struct {
+	kind string
+}
+
+func New(kind string) *ApplicationConfig {
+	return &ApplicationConfig{kind: kind}
+}
+
+func (a ApplicationConfig) Kind() string {
+	return a.kind
+}

example_application/service/client.go

@@ -0,0 +1,22 @@
+package service
+
+import (
+	"autowire"
+	"log"
+)
+
+func init() {
+	autowire.Autowire(&AppClient{})
+}
+
+type Client interface {
+	Connect()
+}
+
+type AppClient struct {
+	Type string
+}
+
+func (AppClient) Connect() {
+	log.Println("Connected")
+}

example_application/service/payment_service.go

@@ -0,0 +1,32 @@
+package service
+
+import (
+	"autowire"
+	"log"
+)
+
+func init() {
+	log.Println("Initializing PaymentService")
+	autowire.RunOmitTest(func() {
+		autowire.Autowire(&BankAccountService{})
+		autowire.Autowire(&PaypalService{})
+	})
+}
+
+type PaymentService interface {
+	Status()
+}
+
+type BankAccountService struct {
+}
+
+func (BankAccountService) Status() {
+	log.Println("BankAccountService...")
+}
+
+type PaypalService struct {
+}
+
+func (PaypalService) Status() {
+	log.Println("PaypalService...")
+}

example_application/service/user_service.go

@@ -0,0 +1,25 @@
+package service
+
+import (
+	"autowire"
+	"autowire/example_application/configuration"
+	"log"
+)
+
+func init() {
+	log.Println("Initializing UserService")
+	s := &UserService{}
+	autowire.Autowire(s)
+}
+
+type UserService struct {
+	Config     *configuration.ApplicationConfig `autowire:""`
+	PaymentSvc PaymentService                   `autowire:"service/BankAccountService"`
+	Client     Client                           `autowire:"service/AppClient"`
+}
+
+func (u UserService) Do() string {
+	u.Client.Connect()
+	u.PaymentSvc.Status()
+	return u.Config.Kind()
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/go-autowire/autowire
+
+go 1.15

profile.go

@@ -0,0 +1,23 @@
+package autowire
+
+import (
+	"os"
+	"regexp"
+	"strings"
+)
+
+type Profile uint64
+
+const (
+	_Default Profile = iota
+	_Testing
+)
+
+func getProfile() Profile {
+	args := os.Args
+	programName := args[0][strings.LastIndex(args[0], "/"):]
+	if result, _ := regexp.MatchString("/.*[Tt]est", programName); result {
+		return _Testing
+	}
+	return _Default
+}

profile_test.go

@@ -0,0 +1,12 @@
+package autowire
+
+import (
+	"testing"
+)
+
+func Test_Profile(t *testing.T) {
+	profile := getProfile()
+	if profile != _Testing {
+		t.Errorf("Expected profile testing found active")
+	}
+}