Prepare Godoc

Author: FilipVPetrov

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 go-autowire
+Copyright (c) 2021 go-autowire
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

atesting/testing.go

@@ -1,10 +1,11 @@
 package atesting
 
 import (
-	"autowire"
 	"container/list"
+	"github.com/go-autowire/autowire"
 	"log"
 	"reflect"
+	"unicode"
 )
 
 func Spy(v interface{}, dependency interface{}) {
@@ -19,7 +20,6 @@ func Spies(v interface{}, dependencies []interface{}) {
 		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:
@@ -29,23 +29,51 @@ func Spies(v interface{}, dependencies []interface{}) {
 		}
 		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))
+							log.Println("Injecting Spy on dependency by tag " + tag + " will be used " + t.Type().String())
+							autowire.Autowire(dependency)
+							setValue(value, elem, i, dependency)
 						}
 					}
 				}
 				if !elem.Field(i).IsNil() {
-					queue.PushBack(elem.Field(i).Elem().Interface())
+					if elem.Field(i).Elem().CanInterface() {
+						queue.PushBack(autowire.Autowired(elem.Field(i).Elem().Interface()))
+					} else {
+						runeName := []rune(elem.Type().Field(i).Name)
+						runeName[0] = unicode.ToUpper(runeName[0])
+						methodName := string(runeName)
+						method := value.MethodByName(methodName)
+						if method.IsValid() {
+							result := method.Call([]reflect.Value{})[0]
+							queue.PushBack(autowire.Autowired(result.Interface()))
+						}
+					}
 				}
 			}
 		}
 	}
 }
+
+func setValue(value reflect.Value, elem reflect.Value, i int, dependency interface{}) bool {
+	runeName := []rune(elem.Type().Field(i).Name)
+	exported := unicode.IsUpper(runeName[0])
+	if exported {
+		elem.Field(i).Set(reflect.ValueOf(dependency))
+	} else {
+		runeName[0] = unicode.ToUpper(runeName[0])
+		methodName := "Set" + string(runeName)
+		method := value.MethodByName(methodName)
+		if method.IsValid() {
+			method.Call([]reflect.Value{reflect.ValueOf(dependency)})
+			return true
+		}
+	}
+	return false
+}

autowire.go

@@ -1,12 +1,14 @@
 package autowire
 
 import (
+	"io"
 	"log"
 	"os"
 	"os/signal"
 	"reflect"
 	"regexp"
 	"strings"
+	"unicode"
 )
 
 var dependencies map[string]interface{}
@@ -19,16 +21,50 @@ 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()
+// InitProd executes function only in production so it is preventing execution in go tests.
+// This flexibility could help if we want to skip autowiring struct in our tests.
+func InitProd(initFunc func()) {
+	if currentProfile == _Production {
+		initFunc()
 	}
 }
 
+// Autowire function injects all dependencies for the given structure v.
+// In order dependencies to be injected the desired struct fields should be marked with
+// autowire tag.
+//
+// Injection of concrete type
+//
+// Currently both type of fields exported and unexported are supported.
+// Following snippet shows injecting dependencies inside private structure fields using `autowire:""` tag:
+//  type Application struct {
+//      config  *configuration.ApplicationConfig `autowire:""`
+//  }
+//  func (a *Application) SetConfig(config  *configuration.ApplicationConfig)  {
+//      a.config = config
+//  }
+// If we need dependency to be injected into unexported field Set<FieldName> function is required, as show above.
+//  type Application struct {
+//      Config  *configuration.ApplicationConfig `autowire:""`
+//  }
+// Injection of dependency into exported is supported also and there is no need to provide additional Setter.
+//
+// Injection of interface
+//
+// Often it`s better to rely on interface instead of concrete type, in order to accomplish this decoupling we specify
+// interfaces as a type of struct fields. The following snippet demonstrate that
+//  type UserService struct {
+//      userRoleRepository UserRoleRepository `autowire:"service/InMemoryUserRoleRepository"`
+//  }
+//  func (u *UserService) SetUserRoleRepository(userRoleRepository UserRoleRepository) {
+//      u.userRoleRepository = userRoleRepository
+//  }
+// UserRoleRepository is simply an interface and InMemoryUserRoleRepository is a struct, which implements this interface.
+// As it`s done dependency injection on unexported field, providing Setter is required. Just to highlight unexported fields
+// needs Setter while exported not. For more information take a look at example package.
 func Autowire(v interface{}) {
 	value := reflect.ValueOf(v)
 	switch value.Kind() {
@@ -38,17 +74,23 @@ func Autowire(v interface{}) {
 		structType := getStructPtrFullPath(value)
 		_, ok := dependencies[structType]
 		if ok {
-			log.Printf("%s already autowired. Going go overwrite it`s value!", structType)
+			log.Printf("%s already autowired... ignored", structType)
 		} else {
+			log.Printf("Autowiring %s", structType)
 			autowireDependencies(value)
 			dependencies[structType] = v
 		}
 	default: // reflect.Array, reflect.Struct, reflect.Interface
 		log.Println(value.Type().String() + " value")
 	}
-	log.Println(dependencies)
+	//log.Println(dependencies)
 }
 
+// Autowired function returns fully initialized with all dependencies instance, which is ready to be used.
+//As the result is empty interface, type assertions is required before using the instance.
+//Take a look at https://golang.org/ref/spec#Type_assertions for more information.
+// The following snippet demonstrate how could be done :
+// 	 app := autowire.Autowired(app.Application{}).(*app.Application)
 func Autowired(v interface{}) interface{} {
 	value := reflect.ValueOf(v)
 	var path string
@@ -62,7 +104,6 @@ func Autowired(v interface{}) interface{} {
 	default:
 		log.Panicln("Unknown Autowired Typed!")
 	}
-	log.Println(path)
 	dependency, ok := dependencies[path]
 	if ok {
 		return dependency
@@ -86,39 +127,62 @@ func autowireDependencies(value reflect.Value) {
 		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)
+						log.Println(msg + ", ready for spy")
 					}
 				} 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]))
+						dependency := currentDep[0]
+						setValue(value, elem, i, dependency)
 					} 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))
+					runeName := []rune(elem.Type().Field(i).Name)
+					exported := unicode.IsUpper(runeName[0])
+					if exported {
+						elem.Field(i).Set(reflect.ValueOf(dependency))
+					} else {
+						runeName[0] = unicode.ToUpper(runeName[0])
+						methodName := "Set" + string(runeName)
+						method := value.MethodByName(methodName)
+						if method.IsValid() {
+							method.Call([]reflect.Value{reflect.ValueOf(dependency)})
+						}
+					}
 				}
 			}
 		}
 	}
 }
 
+func setValue(value reflect.Value, elem reflect.Value, i int, dependency interface{}) {
+	runeName := []rune(elem.Type().Field(i).Name)
+	exported := unicode.IsUpper(runeName[0])
+	if exported {
+		elem.Field(i).Set(reflect.ValueOf(dependency))
+	} else {
+		runeName[0] = unicode.ToUpper(runeName[0])
+		methodName := "Set" + string(runeName)
+		method := value.MethodByName(methodName)
+		if method.IsValid() {
+			method.Call([]reflect.Value{reflect.ValueOf(dependency)})
+		}
+	}
+}
+
 func findDependency(tagDependencyType string) []interface{} {
 	var result []interface{}
 	for tmp, dep := range dependencies {
@@ -129,16 +193,24 @@ func findDependency(tagDependencyType string) []interface{} {
 	return result
 }
 
-type AutoClosable interface {
-	Close()
-}
-
-func Run(mainFunction func()) {
+// Run executes function function after the function execution completes for each autowired struct
+// which implements io.Closer interface will be invoked Call() function, so currently active
+//occupied resources(connections, channels, etc.) could be released.
+func Run(function func()) {
 	defer close()
-	mainFunction()
+	function()
 }
 
 func close() {
-	println("HEREE")
-
+	log.Println("Closing...")
+	for _, dependency := range dependencies {
+		valueDepend := reflect.ValueOf(dependency)
+		closerType := reflect.TypeOf((*io.Closer)(nil)).Elem()
+		if valueDepend.Type().Implements(closerType) {
+			err := dependency.(io.Closer).Close()
+			if err != nil {
+				log.Println(err.Error())
+			}
+		}
+	}
 }

example/app/application.go

@@ -0,0 +1,40 @@
+package app
+
+import (
+	"fmt"
+	"github.com/go-autowire/autowire"
+	"github.com/go-autowire/autowire/example/configuration"
+	"github.com/go-autowire/autowire/example/service"
+	"log"
+)
+
+func init() {
+	autowire.Autowire(&Application{})
+}
+
+type Application struct {
+	config  *configuration.ApplicationConfig `autowire:""`
+	userSvc *service.UserService             `autowire:""`
+}
+
+func (a Application) Start() {
+	log.Println("Config Kind : " + a.config.Kind())
+	userId := "serviceaccount@demo.com"
+	balance, err := a.userSvc.Balance(userId)
+	if err != nil {
+		log.Fatalln(err.Error())
+	}
+	fmt.Println("Current balance is " + balance.String())
+}
+
+func (a *Application) SetConfig(config *configuration.ApplicationConfig) {
+	a.config = config
+}
+
+func (a *Application) SetUserSvc(userSvc *service.UserService) {
+	a.userSvc = userSvc
+}
+
+func (a *Application) UserSvc() *service.UserService {
+	return a.userSvc
+}

example/autowire_test.go

@@ -0,0 +1,33 @@
+package example
+
+import (
+	"github.com/go-autowire/autowire"
+	"github.com/go-autowire/autowire/atesting"
+	"github.com/go-autowire/autowire/example/app"
+	"log"
+	"math/big"
+	"testing"
+)
+
+type TestPaymentServiceTest struct {
+}
+
+func (TestPaymentServiceTest) Balance() *big.Float {
+	log.Println("Mocked object...TestPaymentServiceTest...")
+	balance, _ := new(big.Float).SetString("300.10")
+	return balance
+}
+
+type TestAuditClient struct {
+}
+
+func (TestAuditClient) Send(event string) {
+	log.Printf("Test event delivered")
+}
+
+func TestAutowire(t *testing.T) {
+	app := autowire.Autowired(app.Application{}).(*app.Application)
+	app.UserSvc().PaymentSvc = &TestPaymentServiceTest{}
+	atesting.Spies(app, []interface{}{&TestPaymentServiceTest{}, &TestAuditClient{}})
+	app.Start()
+}

example_application/configuration/application_config.go renamed to example/configuration/application_config.go

@@ -1,13 +1,11 @@
 package configuration
 
 import (
-	"autowire"
-	"log"
+	"github.com/go-autowire/autowire"
 )
 
 func init() {
-	log.Println("Initializing ApplicationConfig")
-	autowire.Autowire(New("con"))
+	autowire.Autowire(New("default"))
 }
 
 type ApplicationConfig struct {