Use KError v0.1.1, KDone v0.2.0 and KInit v0.2.1, private naming fixes

alexeymaximov · alexeymaximov · commit 18478f37e0b0 · 2021-01-31T20:18:20.000+03:00
diff --git a/go.mod b/go.mod
@@ -3,7 +3,7 @@ module github.com/go-kata/kinitx
 go 1.14
 
 require (
-	github.com/go-kata/kdone v0.1.1
-	github.com/go-kata/kerror v0.1.0
-	github.com/go-kata/kinit v0.2.0
+	github.com/go-kata/kdone v0.2.0
+	github.com/go-kata/kerror v0.1.1
+	github.com/go-kata/kinit v0.2.1
 )
diff --git a/go.sum b/go.sum
@@ -2,9 +2,15 @@ github.com/go-kata/kdone v0.1.0 h1:TbIIVxI+q9d8JnjqCwa014bi60zZ1ILKQuk/CIGKzO0=
 github.com/go-kata/kdone v0.1.0/go.mod h1:qNvglTe9URXMYw4vlciLBDU2FLzAqYCoROpxvx8jDwM=
 github.com/go-kata/kdone v0.1.1 h1:GAZlb/vjlQpAn+TtKZez2eZmw/AUpRx94h/Y3A3WLJU=
 github.com/go-kata/kdone v0.1.1/go.mod h1:qNvglTe9URXMYw4vlciLBDU2FLzAqYCoROpxvx8jDwM=
+github.com/go-kata/kdone v0.2.0 h1:ZaCFPwSxthYDfYj1D3r+8fW9iXq8FGt3HT/et+jyauo=
+github.com/go-kata/kdone v0.2.0/go.mod h1:epIfwQvmfhpg7op8E86DZxXOIuz0ZhIHN0kG9r4ye50=
 github.com/go-kata/kerror v0.1.0 h1:Y7y0XGOrhWMU1YxvMAYw5VAeDfo4wUZrhLdSQ+KM7LE=
 github.com/go-kata/kerror v0.1.0/go.mod h1:TtwtjetJ75COpTfrJBL9y2q4MEbDWt1r/FeF5M+5xlw=
+github.com/go-kata/kerror v0.1.1 h1:9RMFNpTzN0HxOZHI2Fm0FBRgx2i+0UkQzIMVvyO33Vs=
+github.com/go-kata/kerror v0.1.1/go.mod h1:TtwtjetJ75COpTfrJBL9y2q4MEbDWt1r/FeF5M+5xlw=
 github.com/go-kata/kinit v0.1.0 h1:sopJkxSkuXBtxBemIavqw/qlajBpz77xSUrrfWo0Lx8=
 github.com/go-kata/kinit v0.1.0/go.mod h1:ErsGPU8fCxUFM+uvlqtcjo0VGj7xXosLyHbmb+yYero=
 github.com/go-kata/kinit v0.2.0 h1:rI5w2KCdnTFK7hJ9Is6zBI5b4QS7RvihtX8oCexPyG8=
 github.com/go-kata/kinit v0.2.0/go.mod h1:EdagOVrXQtJXZmAkIceRVhKq/jgscLua6GNzVAlpth0=
+github.com/go-kata/kinit v0.2.1 h1:8YvYoTHphqrs3VH4CQ4pjkAjsc6pPKB/QKWevDkngX0=
+github.com/go-kata/kinit v0.2.1/go.mod h1:/WhSVUU9G4gIemg7Yh7dApBFu768MB501io9xWegnbs=
diff --git a/kinitx.go b/kinitx.go
@@ -33,7 +33,7 @@ var executorType = reflect.TypeOf((*kinit.Executor)(nil)).Elem()
 //
 // All other variants of x are unacceptable.
 func Provide(x interface{}) error {
-	ctor, err := chooseConstructor(x)
+	ctor, err := newProperConstructor(x)
 	if err != nil {
 		return err
 	}
diff --git a/proper.go b/proper.go
@@ -7,10 +7,10 @@ import (
 	"github.com/go-kata/kinit"
 )
 
-// chooseConstructor returns a new constructor based on the given entity.
+// newProperConstructor returns a new constructor based on the given entity.
 //
 // See the documentation for the Provide to find out possible values of the argument x.
-func chooseConstructor(x interface{}) (kinit.Constructor, error) {
+func newProperConstructor(x interface{}) (kinit.Constructor, error) {
 	if x == nil {
 		return nil, kerror.New(kerror.ERuntime, "function, struct or struct pointer expected, nil given")
 	}
diff --git a/proper_test.go b/proper_test.go
@@ -13,8 +13,8 @@ func (*testCloser) Close() error {
 	return nil
 }
 
-func TestChooseConstructorWithConstructor(t *testing.T) {
-	ctor, err := chooseConstructor(func() int { return 0 })
+func TestNewProperConstructorWithConstructor(t *testing.T) {
+	ctor, err := newProperConstructor(func() int { return 0 })
 	if err != nil {
 		t.Logf("%+v", err)
 		t.Fail()
@@ -26,8 +26,8 @@ func TestChooseConstructorWithConstructor(t *testing.T) {
 	}
 }
 
-func TestChooseConstructorWithOpener(t *testing.T) {
-	ctor, err := chooseConstructor(func() *testCloser { return &testCloser{} })
+func TestNewProperConstructorWithOpener(t *testing.T) {
+	ctor, err := newProperConstructor(func() *testCloser { return &testCloser{} })
 	if err != nil {
 		t.Logf("%+v", err)
 		t.Fail()
@@ -39,8 +39,8 @@ func TestChooseConstructorWithOpener(t *testing.T) {
 	}
 }
 
-func TestChooseConstructorWithConstructorOfCloser(t *testing.T) {
-	ctor, err := chooseConstructor(func() (*testCloser, kdone.Destructor, error) {
+func TestNewProperConstructorWithConstructorOfCloser(t *testing.T) {
+	ctor, err := newProperConstructor(func() (*testCloser, kdone.Destructor, error) {
 		return &testCloser{}, kdone.Noop, nil
 	})
 	if err != nil {
@@ -54,8 +54,8 @@ func TestChooseConstructorWithConstructorOfCloser(t *testing.T) {
 	}
 }
 
-func TestChooseConstructorWithStruct(t *testing.T) {
-	ctor, err := chooseConstructor(testCloser{})
+func TestNewProperConstructorWithStruct(t *testing.T) {
+	ctor, err := newProperConstructor(testCloser{})
 	if err != nil {
 		t.Logf("%+v", err)
 		t.Fail()
@@ -67,8 +67,8 @@ func TestChooseConstructorWithStruct(t *testing.T) {
 	}
 }
 
-func TestChooseConstructorWithStructPointer(t *testing.T) {
-	ctor, err := chooseConstructor((*testCloser)(nil))
+func TestNewProperConstructorWithStructPointer(t *testing.T) {
+	ctor, err := newProperConstructor((*testCloser)(nil))
 	if err != nil {
 		t.Logf("%+v", err)
 		t.Fail()
@@ -80,26 +80,26 @@ func TestChooseConstructorWithStructPointer(t *testing.T) {
 	}
 }
 
-func TestChooseConstructorWithWrongX(t *testing.T) {
-	_, err := chooseConstructor(0)
+func TestNewProperConstructorWithWrongX(t *testing.T) {
+	_, err := newProperConstructor(0)
 	t.Logf("%+v", err)
 	if kerror.ClassOf(err) != kerror.ERuntime {
 		t.Fail()
 		return
 	}
 }
 
-func TestChooseConstructorWithWrongFunc(t *testing.T) {
-	_, err := chooseConstructor(func() {})
+func TestNewProperConstructorWithWrongFunc(t *testing.T) {
+	_, err := newProperConstructor(func() {})
 	t.Logf("%+v", err)
 	if kerror.ClassOf(err) != kerror.ERuntime {
 		t.Fail()
 		return
 	}
 }
 
-func TestChooseConstructorWithWrongPointer(t *testing.T) {
-	_, err := chooseConstructor((*int)(nil))
+func TestNewProperConstructorWithWrongPointer(t *testing.T) {
+	_, err := newProperConstructor((*int)(nil))
 	t.Logf("%+v", err)
 	if kerror.ClassOf(err) != kerror.ERuntime {
 		t.Fail()

Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ var executorType = reflect.TypeOf((*kinit.Executor)(nil)).Elem()`
`33`	`33`	`//`
`34`	`34`	`// All other variants of x are unacceptable.`
`35`	`35`	`func Provide(x interface{}) error {`
`36`		`- ctor, err := chooseConstructor(x)`
	`36`	`+ ctor, err := newProperConstructor(x)`
`37`	`37`	`if err != nil {`
`38`	`38`	`return err`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,10 @@ import (`
`7`	`7`	`"github.com/go-kata/kinit"`
`8`	`8`	`)`
`9`	`9`
`10`		`-// chooseConstructor returns a new constructor based on the given entity.`
	`10`	`+// newProperConstructor returns a new constructor based on the given entity.`
`11`	`11`	`//`
`12`	`12`	`// See the documentation for the Provide to find out possible values of the argument x.`
`13`		`-func chooseConstructor(x interface{}) (kinit.Constructor, error) {`
	`13`	`+func newProperConstructor(x interface{}) (kinit.Constructor, error) {`
`14`	`14`	`if x == nil {`
`15`	`15`	`return nil, kerror.New(kerror.ERuntime, "function, struct or struct pointer expected, nil given")`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,8 @@ func (*testCloser) Close() error {`
`13`	`13`	`return nil`
`14`	`14`	`}`
`15`	`15`
`16`		`-func TestChooseConstructorWithConstructor(t *testing.T) {`
`17`		`- ctor, err := chooseConstructor(func() int { return 0 })`
	`16`	`+func TestNewProperConstructorWithConstructor(t *testing.T) {`
	`17`	`+ ctor, err := newProperConstructor(func() int { return 0 })`
`18`	`18`	`if err != nil {`
`19`	`19`	`t.Logf("%+v", err)`
`20`	`20`	`t.Fail()`
`@@ -26,8 +26,8 @@ func TestChooseConstructorWithConstructor(t *testing.T) {`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
`29`		`-func TestChooseConstructorWithOpener(t *testing.T) {`
`30`		`- ctor, err := chooseConstructor(func() *testCloser { return &testCloser{} })`
	`29`	`+func TestNewProperConstructorWithOpener(t *testing.T) {`
	`30`	`+ ctor, err := newProperConstructor(func() *testCloser { return &testCloser{} })`
`31`	`31`	`if err != nil {`
`32`	`32`	`t.Logf("%+v", err)`
`33`	`33`	`t.Fail()`
`@@ -39,8 +39,8 @@ func TestChooseConstructorWithOpener(t *testing.T) {`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`		`-func TestChooseConstructorWithConstructorOfCloser(t *testing.T) {`
`43`		`- ctor, err := chooseConstructor(func() (*testCloser, kdone.Destructor, error) {`
	`42`	`+func TestNewProperConstructorWithConstructorOfCloser(t *testing.T) {`
	`43`	`+ ctor, err := newProperConstructor(func() (*testCloser, kdone.Destructor, error) {`
`44`	`44`	`return &testCloser{}, kdone.Noop, nil`
`45`	`45`	`})`
`46`	`46`	`if err != nil {`
`@@ -54,8 +54,8 @@ func TestChooseConstructorWithConstructorOfCloser(t *testing.T) {`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
`57`		`-func TestChooseConstructorWithStruct(t *testing.T) {`
`58`		`- ctor, err := chooseConstructor(testCloser{})`
	`57`	`+func TestNewProperConstructorWithStruct(t *testing.T) {`
	`58`	`+ ctor, err := newProperConstructor(testCloser{})`
`59`	`59`	`if err != nil {`
`60`	`60`	`t.Logf("%+v", err)`
`61`	`61`	`t.Fail()`
`@@ -67,8 +67,8 @@ func TestChooseConstructorWithStruct(t *testing.T) {`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
`70`		`-func TestChooseConstructorWithStructPointer(t *testing.T) {`
`71`		`- ctor, err := chooseConstructor((*testCloser)(nil))`
	`70`	`+func TestNewProperConstructorWithStructPointer(t *testing.T) {`
	`71`	`+ ctor, err := newProperConstructor((*testCloser)(nil))`
`72`	`72`	`if err != nil {`
`73`	`73`	`t.Logf("%+v", err)`
`74`	`74`	`t.Fail()`
`@@ -80,26 +80,26 @@ func TestChooseConstructorWithStructPointer(t *testing.T) {`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`
`83`		`-func TestChooseConstructorWithWrongX(t *testing.T) {`
`84`		`- _, err := chooseConstructor(0)`
	`83`	`+func TestNewProperConstructorWithWrongX(t *testing.T) {`
	`84`	`+ _, err := newProperConstructor(0)`
`85`	`85`	`t.Logf("%+v", err)`
`86`	`86`	`if kerror.ClassOf(err) != kerror.ERuntime {`
`87`	`87`	`t.Fail()`
`88`	`88`	`return`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`
`92`		`-func TestChooseConstructorWithWrongFunc(t *testing.T) {`
`93`		`- _, err := chooseConstructor(func() {})`
	`92`	`+func TestNewProperConstructorWithWrongFunc(t *testing.T) {`
	`93`	`+ _, err := newProperConstructor(func() {})`
`94`	`94`	`t.Logf("%+v", err)`
`95`	`95`	`if kerror.ClassOf(err) != kerror.ERuntime {`
`96`	`96`	`t.Fail()`
`97`	`97`	`return`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`
`101`		`-func TestChooseConstructorWithWrongPointer(t *testing.T) {`
`102`		`- _, err := chooseConstructor((*int)(nil))`
	`101`	`+func TestNewProperConstructorWithWrongPointer(t *testing.T) {`
	`102`	`+ _, err := newProperConstructor((*int)(nil))`
`103`	`103`	`t.Logf("%+v", err)`
`104`	`104`	`if kerror.ClassOf(err) != kerror.ERuntime {`
`105`	`105`	`t.Fail()`