From 3376f13a4082ed3e63b650f7cf3b12b19d1fbe56 Mon Sep 17 00:00:00 2001 From: tsaikd Date: Sat, 2 Jan 2016 00:01:19 +0800 Subject: [PATCH] support Provide() for lazy get Signed-off-by: tsaikd --- README.md | 2 ++ inject.go | 55 +++++++++++++++++++++++++++++++++++++++++++------- inject_test.go | 45 +++++++++++++++++++++++++++++++++++++++-- 3 files changed, 93 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 679abe0..c7c42f8 100644 --- a/README.md +++ b/README.md @@ -79,6 +79,8 @@ type TypeMapper interface { // This is really only useful for mapping a value as an interface, as interfaces // cannot at this time be referenced directly without a pointer. MapTo(interface{}, interface{}) TypeMapper + // Provide the dynamic type of interface{} returns, + Provide(interface{}) TypeMapper // Provides a possibility to directly insert a mapping based on type and value. // This makes it possible to directly map type arguments not possible to instantiate // with reflect like unidirectional channels. diff --git a/inject.go b/inject.go index 3ff713c..41ef967 100644 --- a/inject.go +++ b/inject.go @@ -43,6 +43,8 @@ type TypeMapper interface { // This is really only useful for mapping a value as an interface, as interfaces // cannot at this time be referenced directly without a pointer. MapTo(interface{}, interface{}) TypeMapper + // Provide the dynamic type of interface{} returns, + Provide(interface{}) TypeMapper // Provides a possibility to directly insert a mapping based on type and value. // This makes it possible to directly map type arguments not possible to instantiate // with reflect like unidirectional channels. @@ -53,8 +55,9 @@ type TypeMapper interface { } type injector struct { - values map[reflect.Type]reflect.Value - parent Injector + values map[reflect.Type]reflect.Value + providers map[reflect.Type]reflect.Value + parent Injector } // InterfaceOf dereferences a pointer to an Interface type. @@ -76,7 +79,8 @@ func InterfaceOf(value interface{}) reflect.Type { // New returns a new Injector. func New() Injector { return &injector{ - values: make(map[reflect.Type]reflect.Value), + values: make(map[reflect.Type]reflect.Value), + providers: make(map[reflect.Type]reflect.Value), } } @@ -148,8 +152,22 @@ func (i *injector) MapTo(val interface{}, ifacePtr interface{}) TypeMapper { return i } +// Provide the dynamic type of provider returns, +// It returns the TypeMapper registered in. +func (inj *injector) Provide(provider interface{}) TypeMapper { + val := reflect.ValueOf(provider) + t := val.Type() + numout := t.NumOut() + for i := 0; i < numout; i++ { + out := t.Out(i) + inj.providers[out] = val + } + return inj +} + // Maps the given reflect.Type to the given reflect.Value and returns // the Typemapper the mapping has been registered in. +// It panics if invoke provider failed. func (i *injector) Set(typ reflect.Type, val reflect.Value) TypeMapper { i.values[typ] = val return i @@ -162,19 +180,42 @@ func (i *injector) Get(t reflect.Type) reflect.Value { return val } + // try to find providers + if provider, ok := i.providers[t]; ok { + // invoke provider to inject return values + results, err := i.Invoke(provider.Interface()) + if err != nil { + panic(err) + } + for _, result := range results { + resultType := result.Type() + + i.values[resultType] = result + + // provider should not be called again + delete(i.providers, resultType) + + if resultType == t { + val = result + } + } + if val.IsValid() { + return val + } + } + // no concrete types found, try to find implementors // if t is an interface if t.Kind() == reflect.Interface { for k, v := range i.values { - if k.Implements(t) { - val = v - break + if k.Implements(t) && v.IsValid() { + return v } } } // Still no type found, try to look it up on the parent - if !val.IsValid() && i.parent != nil { + if i.parent != nil { val = i.parent.Get(t) } diff --git a/inject_test.go b/inject_test.go index eb94471..bc262fd 100644 --- a/inject_test.go +++ b/inject_test.go @@ -2,9 +2,10 @@ package inject_test import ( "fmt" - "github.com/codegangsta/inject" "reflect" "testing" + + "github.com/tsaikd/inject" ) type SpecialString interface { @@ -21,7 +22,7 @@ type Greeter struct { } func (g *Greeter) String() string { - return "Hello, My name is" + g.Name + return "Hello, My name is " + g.Name } /* Test Helpers */ @@ -157,3 +158,43 @@ func TestInjectImplementors(t *testing.T) { expect(t, injector.Get(inject.InterfaceOf((*fmt.Stringer)(nil))).IsValid(), true) } + +func Test_InjectorProvideStruct(t *testing.T) { + injector := inject.New() + + expect(t, injector.Get(reflect.TypeOf(&TestStruct{})).IsValid(), false) + + injector.Provide(func() *TestStruct { + return &TestStruct{ + Dep3: "test", + } + }) + + injectedStruct := injector.Get(reflect.TypeOf(&TestStruct{})) + expect(t, injectedStruct.IsValid(), true) + if injectedStruct.IsValid() { + expect(t, injectedStruct.Interface().(*TestStruct).Dep3, "test") + } + + _, err := injector.Invoke(func(s1 *TestStruct) { + expect(t, s1.Dep3, "test") + }) + expect(t, err, nil) +} + +func Test_InjectorProvideInterface(t *testing.T) { + injector := inject.New() + + expect(t, injector.Get(inject.InterfaceOf((*fmt.Stringer)(nil))).IsValid(), false) + + injector.Provide(func() fmt.Stringer { + return &Greeter{"Jeremy"} + }) + + expect(t, injector.Get(inject.InterfaceOf((*fmt.Stringer)(nil))).IsValid(), true) + + _, err := injector.Invoke(func(stringer fmt.Stringer) { + expect(t, stringer.String(), "Hello, My name is Jeremy") + }) + expect(t, err, nil) +}