Merge pull request #72 from gone-io/feature/loader

Rewrite core with new architecture
Supports injected name with wildcards
Add more test cases, 100% coverage

Author: Degfy

application.go

@@ -9,7 +9,7 @@ import (
 type Application struct {
 	Flag
 
-	loader  *Core    `gone:"*"`
+	loader  *core    `gone:"*"`
 	daemons []Daemon `gone:"*"`
 
 	beforeStartHooks []Process
@@ -45,7 +45,7 @@ func Prepare(loads ...LoadFunc) *Application {
 
 func (s *Application) init() *Application {
 	s.signal = make(chan os.Signal, 1)
-	s.loader = NewCore()
+	s.loader = newCore()
 
 	s.
 		Load(s, IsDefault()).
@@ -236,8 +236,8 @@ func (s *Application) Run(fn ...any) {
 	s.stop()
 }
 
-func Run(fn any) {
-	Default.Run(fn)
+func Run(fn ...any) {
+	Default.Run(fn...)
 }
 
 // Serve initializes the application, starts all daemons, and waits for termination signal.

application_test.go

@@ -544,3 +544,17 @@ func TestMustLoadPanic(t *testing.T) {
 		t.Errorf("Expected duplicate name error, got %s", err.Error())
 	}
 }
+
+func TestPrepare(t *testing.T) {
+	gone.Prepare().Run()
+}
+
+func TestEnd(t *testing.T) {
+	gone.
+		Default.
+		AfterStart(func() {
+			time.Sleep(1 * time.Millisecond)
+			gone.End()
+		}).
+		Serve()
+}

codecov.yml

@@ -0,0 +1,3 @@
+ignore:
+  - "**/*_mock.go"
+  - "*_mock.go"

coffin.go

@@ -1,6 +1,7 @@
 package gone
 
 import (
+	"fmt"
 	"reflect"
 	"sort"
 )
@@ -14,36 +15,89 @@ type coffin struct {
 	onlyForName  bool
 	forceReplace bool
 
-	defaultTypeMap    map[reflect.Type]bool
-	lazyFill          bool
-	needInitBeforeUse bool
-	isFill            bool
-	isInit            bool
-	provider          *wrapProvider
+	defaultTypeMap      map[reflect.Type]bool
+	lazyFill            bool
+	needInitBeforeUse   bool
+	isFill              bool
+	isInit              bool
+	provider            *wrapProvider
+	namedProvider       NamedProvider
+	structFieldInjector StructFieldInjector
 }
 
 func newCoffin(goner any) *coffin {
-	_, needInitBeforeUse := goner.(Initiator)
-	if !needInitBeforeUse {
-		_, needInitBeforeUse = goner.(InitiatorNoError)
+	co := &coffin{
+		goner:          goner,
+		defaultTypeMap: make(map[reflect.Type]bool),
 	}
-	provider := tryWrapGonerToProvider(goner)
-	if provider != nil {
-		needInitBeforeUse = true
+
+	if namedGoner, ok := goner.(NamedGoner); ok {
+		co.name = namedGoner.GonerName()
+	}
+
+	if namedProvider, ok := goner.(NamedProvider); ok {
+		co.needInitBeforeUse = true
+		co.namedProvider = namedProvider
+	} else if provider := tryWrapGonerToProvider(goner); provider != nil {
+		co.needInitBeforeUse = true
+		co.provider = provider
+		//co.defaultTypeMap[provider.Type()] = true
+	} else if _, ok := goner.(Initiator); ok {
+		co.needInitBeforeUse = true
+	} else if _, ok := goner.(InitiatorNoError); ok {
+		co.needInitBeforeUse = true
+	} else if _, ok := goner.(StructFieldInjector); ok {
+		co.needInitBeforeUse = true
+	}
+
+	return co
+}
+
+func (c *coffin) Name() string {
+	if c.name != "" {
+		return fmt.Sprintf("Goner(name=%s)", c.name)
+	}
+	return fmt.Sprintf("%T", c.goner)
+}
+
+func (c *coffin) CoundProvide(t reflect.Type, byName bool) error {
+	if IsCompatible(t, c.goner) {
+		return nil
+	}
+
+	if c.provider != nil && c.provider.ProvideTypeCompatible(t) {
+		return nil
 	}
-	if !needInitBeforeUse {
-		_, needInitBeforeUse = goner.(NamedProvider)
+
+	if c.namedProvider != nil && (byName || c.isDefault(t)) {
+		return nil
 	}
-	if !needInitBeforeUse {
-		_, needInitBeforeUse = goner.(StructFieldInjector)
+
+	return NewInnerErrorWithParams(GonerTypeNotMatch, "%q cannot provide %q value", c.Name(), GetTypeName(t))
+}
+
+func (c *coffin) AddToDefault(t reflect.Type) error {
+	if err := c.CoundProvide(t, true); err != nil {
+		return err
 	}
+	c.defaultTypeMap[t] = true
+	return nil
+}
 
-	return &coffin{
-		goner:             goner,
-		defaultTypeMap:    make(map[reflect.Type]bool),
-		needInitBeforeUse: needInitBeforeUse,
-		provider:          provider,
+func (c *coffin) Provide(byName bool, tagConf string, t reflect.Type) (any, error) {
+	if IsCompatible(t, c.goner) {
+		return c.goner, nil
 	}
+
+	if c.provider != nil && c.provider.ProvideTypeCompatible(t) {
+		return c.provider.Provide(tagConf)
+	}
+
+	if c.namedProvider != nil && (byName || c.isDefault(t)) {
+		return c.namedProvider.Provide(tagConf, t)
+	}
+
+	return nil, NewInnerErrorWithParams(NotSupport, "gone: %s cannot provide %s value", c.Name(), GetTypeName(t))
 }
 
 func (c *coffin) isDefault(t reflect.Type) bool {