diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml index 454d768..e48c844 100644 --- a/.github/workflows/golangci-lint.yml +++ b/.github/workflows/golangci-lint.yml @@ -16,4 +16,4 @@ jobs: - name: golangci-lint uses: golangci/golangci-lint-action@v2 with: - version: v1.50.1 + version: v1.52.2 diff --git a/assign.go b/assign.go index a0da834..92d3e19 100644 --- a/assign.go +++ b/assign.go @@ -22,7 +22,7 @@ import ( // is a short hand wrapper to discard error return func Set(in interface{}, val interface{}, path string) error { if in == nil { - return errors.New("Cannot Set nil") + return errors.New("cannot set nil") } parts := []string{} if path != "" { @@ -36,7 +36,7 @@ func setByParts(in interface{}, val interface{}, parts []string) error { if in == nil { // nil interface can happen during traversing the path - return errors.New("Cannot traverse nil/uninitialized interface{}") + return errors.New("cannot traverse nil/uninitialized interface{}") } inValue := reflect.ValueOf(in) diff --git a/builder.go b/builder.go index 6dfc814..2dcce05 100644 --- a/builder.go +++ b/builder.go @@ -46,7 +46,7 @@ type Builder interface { Values() interface{} } -// Chain creates a simple new go-funk.Builder from a collection. Each method +// Chain creates a simple new go-funk.Builder from a collection. Each method // call generate a new builder containing the previous result. func Chain(v interface{}) Builder { isNotNil(v, "Chain") @@ -73,13 +73,12 @@ func LazyChain(v interface{}) Builder { } panic(fmt.Sprintf("Type %s is not supported by LazyChain", valueType.String())) - } -// LazyChainWith creates a lazy go-funk.Builder from a generator. Like LazyChain, each +// LazyChainWith creates a lazy go-funk.Builder from a generator. Like LazyChain, each // method call generate a new builder containing a method generating the previous value. // But, instead of using a collection, it takes a generator which can generate values. -// With LazyChainWith, to can create a generic pipeline of collection transformation and, +// With LazyChainWith, to can create a generic pipeline of collection transformation and, // throw the generator, sending different collection. func LazyChainWith(generator func() interface{}) Builder { isNotNil(generator, "LazyChainWith") diff --git a/chain_builder_test.go b/chain_builder_test.go index 0835b55..1ef4788 100644 --- a/chain_builder_test.go +++ b/chain_builder_test.go @@ -128,10 +128,10 @@ func TestChainFilter_SideEffect(t *testing.T) { type foo struct { bar string } - in := []*foo{&foo{"foo"}, &foo{"bar"}} + in := []*foo{{"foo"}, {"bar"}} chain := Chain(in) - is.Equal([]*foo{&foo{"foo"}, &foo{"bar"}}, chain.Value()) + is.Equal([]*foo{{"foo"}, {"bar"}}, chain.Value()) filtered := chain.Filter(func(x *foo) bool { x.bar = "__" + x.bar + "__" @@ -140,8 +140,8 @@ func TestChainFilter_SideEffect(t *testing.T) { is.Equal([]*foo{}, filtered.Value()) // Side effect: in and chain.Value modified - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, chain.Value()) - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, in) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, chain.Value()) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, in) } func TestChainFlatten(t *testing.T) { @@ -318,10 +318,10 @@ func TestChainMap_SideEffect(t *testing.T) { type foo struct { bar string } - in := []*foo{&foo{"foo"}, &foo{"bar"}} + in := []*foo{{"foo"}, {"bar"}} chain := Chain(in) - is.Equal([]*foo{&foo{"foo"}, &foo{"bar"}}, chain.Value()) + is.Equal([]*foo{{"foo"}, {"bar"}}, chain.Value()) mapped := chain.Map(func(x *foo) (string, bool) { x.bar = "__" + x.bar + "__" @@ -330,8 +330,8 @@ func TestChainMap_SideEffect(t *testing.T) { is.Equal(map[string]bool{"__foo__": false, "__bar__": false}, mapped.Value()) // Side effect: in and chain.Value modified - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, chain.Value()) - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, in) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, chain.Value()) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, in) } func TestChainReverse(t *testing.T) { @@ -492,8 +492,8 @@ func TestChainContains(t *testing.T) { Contains: "bar", }, { - In: []string{"foo", "bar"}, - Contains: func (value string) bool { + In: []string{"foo", "bar"}, + Contains: func(value string) bool { return value == "bar" }, }, @@ -526,8 +526,8 @@ func TestChainContains(t *testing.T) { Contains: 2, }, { - In: map[int]*Foo{1: f, 3: c}, - Contains: func (key int, foo *Foo) bool { + In: map[int]*Foo{1: f, 3: c}, + Contains: func(key int, foo *Foo) bool { return key == 3 && foo.FirstName == "Harald" }, }, @@ -625,10 +625,10 @@ func TestChainFind_SideEffect(t *testing.T) { type foo struct { bar string } - in := []*foo{&foo{"foo"}, &foo{"bar"}} + in := []*foo{{"foo"}, {"bar"}} chain := Chain(in) - is.Equal([]*foo{&foo{"foo"}, &foo{"bar"}}, chain.Value()) + is.Equal([]*foo{{"foo"}, {"bar"}}, chain.Value()) result := chain.Find(func(x *foo) bool { x.bar = "__" + x.bar + "__" @@ -637,8 +637,8 @@ func TestChainFind_SideEffect(t *testing.T) { is.Nil(result) // Side effect: in and chain.Value modified - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, chain.Value()) - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, in) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, chain.Value()) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, in) } func TestChainForEach(t *testing.T) { @@ -690,20 +690,20 @@ func TestChainForEach_SideEffect(t *testing.T) { bar string } var out []*foo - in := []*foo{&foo{"foo"}, &foo{"bar"}} + in := []*foo{{"foo"}, {"bar"}} chain := Chain(in) - is.Equal([]*foo{&foo{"foo"}, &foo{"bar"}}, chain.Value()) + is.Equal([]*foo{{"foo"}, {"bar"}}, chain.Value()) chain.ForEach(func(x *foo) { x.bar = "__" + x.bar + "__" out = append(out, x) }) - is.Equal([]*foo{&foo{"__foo__"}, &foo{"__bar__"}}, out) + is.Equal([]*foo{{"__foo__"}, {"__bar__"}}, out) // Side effect: in and chain.Value modified - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, chain.Value()) - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, in) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, chain.Value()) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, in) } func TestChainForEachRight(t *testing.T) { @@ -755,20 +755,20 @@ func TestChainForEachRight_SideEffect(t *testing.T) { bar string } var out []*foo - in := []*foo{&foo{"foo"}, &foo{"bar"}} + in := []*foo{{"foo"}, {"bar"}} chain := Chain(in) - is.Equal([]*foo{&foo{"foo"}, &foo{"bar"}}, chain.Value()) + is.Equal([]*foo{{"foo"}, {"bar"}}, chain.Value()) chain.ForEachRight(func(x *foo) { x.bar = "__" + x.bar + "__" out = append(out, x) }) - is.Equal([]*foo{&foo{"__bar__"}, &foo{"__foo__"}}, out) + is.Equal([]*foo{{"__bar__"}, {"__foo__"}}, out) // Side effect: in and chain.Value modified - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, chain.Value()) - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, in) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, chain.Value()) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, in) } func TestChainHead(t *testing.T) { @@ -823,8 +823,8 @@ func TestChainIndexOf(t *testing.T) { Item: "bar", }, { - In: []string{"foo", "bar"}, - Item: func (value string) bool { + In: []string{"foo", "bar"}, + Item: func(value string) bool { return value == "bar" }, }, @@ -907,8 +907,8 @@ func TestChainLastIndexOf(t *testing.T) { Item: "bar", }, { - In: []string{"foo", "bar", "bar"}, - Item: func (value string) bool { + In: []string{"foo", "bar", "bar"}, + Item: func(value string) bool { return value == "bar" }, }, diff --git a/fill.go b/fill.go index 6af5cfa..a759d87 100644 --- a/fill.go +++ b/fill.go @@ -11,14 +11,14 @@ func Fill(in interface{}, fillValue interface{}) (interface{}, error) { inValue := reflect.ValueOf(in) inKind := inValue.Type().Kind() if inKind != reflect.Slice && inKind != reflect.Array { - return nil, errors.New("Can only fill slices and arrays") + return nil, errors.New("can only fill slices and arrays") } inType := reflect.TypeOf(in).Elem() value := reflect.ValueOf(fillValue) if inType != value.Type() { return nil, fmt.Errorf( - "Cannot fill '%s' with '%s'", reflect.TypeOf(in), value.Type(), + "cannot fill '%s' with '%s'", reflect.TypeOf(in), value.Type(), ) } diff --git a/lazy_builder_test.go b/lazy_builder_test.go index 56816e7..e07f5d2 100644 --- a/lazy_builder_test.go +++ b/lazy_builder_test.go @@ -128,10 +128,10 @@ func TestLazyFilter_SideEffect(t *testing.T) { type foo struct { bar string } - in := []*foo{&foo{"foo"}, &foo{"bar"}} + in := []*foo{{"foo"}, {"bar"}} LazyChain := LazyChain(in) - is.Equal([]*foo{&foo{"foo"}, &foo{"bar"}}, LazyChain.Value()) + is.Equal([]*foo{{"foo"}, {"bar"}}, LazyChain.Value()) filtered := LazyChain.Filter(func(x *foo) bool { x.bar = "__" + x.bar + "__" @@ -140,8 +140,8 @@ func TestLazyFilter_SideEffect(t *testing.T) { is.Equal([]*foo{}, filtered.Value()) // Side effect: in and LazyChain.Value modified - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, LazyChain.Value()) - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, in) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, LazyChain.Value()) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, in) } func TestLazyFlatten(t *testing.T) { @@ -318,10 +318,10 @@ func TestLazyMap_SideEffect(t *testing.T) { type foo struct { bar string } - in := []*foo{&foo{"foo"}, &foo{"bar"}} + in := []*foo{{"foo"}, {"bar"}} LazyChain := LazyChain(in) - is.Equal([]*foo{&foo{"foo"}, &foo{"bar"}}, LazyChain.Value()) + is.Equal([]*foo{{"foo"}, {"bar"}}, LazyChain.Value()) mapped := LazyChain.Map(func(x *foo) (string, bool) { x.bar = "__" + x.bar + "__" @@ -330,8 +330,8 @@ func TestLazyMap_SideEffect(t *testing.T) { is.Equal(map[string]bool{"__foo__": false, "__bar__": false}, mapped.Value()) // Side effect: in and LazyChain.Value modified - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, LazyChain.Value()) - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, in) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, LazyChain.Value()) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, in) } func TestLazyReverse(t *testing.T) { @@ -492,8 +492,8 @@ func TestLazyContains(t *testing.T) { Contains: "bar", }, { - In: []string{"foo", "bar"}, - Contains: func (value string) bool { + In: []string{"foo", "bar"}, + Contains: func(value string) bool { return value == "bar" }, }, @@ -526,8 +526,8 @@ func TestLazyContains(t *testing.T) { Contains: 2, }, { - In: map[int]*Foo{1: f, 3: c}, - Contains: func (key int, foo *Foo) bool { + In: map[int]*Foo{1: f, 3: c}, + Contains: func(key int, foo *Foo) bool { return key == 3 && foo.FirstName == "Harald" }, }, @@ -625,10 +625,10 @@ func TestLazyFind_SideEffect(t *testing.T) { type foo struct { bar string } - in := []*foo{&foo{"foo"}, &foo{"bar"}} + in := []*foo{{"foo"}, {"bar"}} LazyChain := LazyChain(in) - is.Equal([]*foo{&foo{"foo"}, &foo{"bar"}}, LazyChain.Value()) + is.Equal([]*foo{{"foo"}, {"bar"}}, LazyChain.Value()) result := LazyChain.Find(func(x *foo) bool { x.bar = "__" + x.bar + "__" @@ -637,8 +637,8 @@ func TestLazyFind_SideEffect(t *testing.T) { is.Nil(result) // Side effect: in and LazyChain.Value modified - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, LazyChain.Value()) - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, in) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, LazyChain.Value()) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, in) } func TestLazyForEach(t *testing.T) { @@ -690,20 +690,20 @@ func TestLazyForEach_SideEffect(t *testing.T) { bar string } var out []*foo - in := []*foo{&foo{"foo"}, &foo{"bar"}} + in := []*foo{{"foo"}, {"bar"}} LazyChain := LazyChain(in) - is.Equal([]*foo{&foo{"foo"}, &foo{"bar"}}, LazyChain.Value()) + is.Equal([]*foo{{"foo"}, {"bar"}}, LazyChain.Value()) LazyChain.ForEach(func(x *foo) { x.bar = "__" + x.bar + "__" out = append(out, x) }) - is.Equal([]*foo{&foo{"__foo__"}, &foo{"__bar__"}}, out) + is.Equal([]*foo{{"__foo__"}, {"__bar__"}}, out) // Side effect: in and LazyChain.Value modified - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, LazyChain.Value()) - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, in) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, LazyChain.Value()) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, in) } func TestLazyForEachRight(t *testing.T) { @@ -755,20 +755,20 @@ func TestLazyForEachRight_SideEffect(t *testing.T) { bar string } var out []*foo - in := []*foo{&foo{"foo"}, &foo{"bar"}} + in := []*foo{{"foo"}, {"bar"}} LazyChain := LazyChain(in) - is.Equal([]*foo{&foo{"foo"}, &foo{"bar"}}, LazyChain.Value()) + is.Equal([]*foo{{"foo"}, {"bar"}}, LazyChain.Value()) LazyChain.ForEachRight(func(x *foo) { x.bar = "__" + x.bar + "__" out = append(out, x) }) - is.Equal([]*foo{&foo{"__bar__"}, &foo{"__foo__"}}, out) + is.Equal([]*foo{{"__bar__"}, {"__foo__"}}, out) // Side effect: in and LazyChain.Value modified - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, LazyChain.Value()) - is.NotEqual([]*foo{&foo{"foo"}, &foo{"bar"}}, in) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, LazyChain.Value()) + is.NotEqual([]*foo{{"foo"}, {"bar"}}, in) } func TestLazyHead(t *testing.T) { @@ -823,8 +823,8 @@ func TestLazyIndexOf(t *testing.T) { Item: "bar", }, { - In: []string{"foo", "bar"}, - Item: func (value string) bool { + In: []string{"foo", "bar"}, + Item: func(value string) bool { return value == "bar" }, }, @@ -907,8 +907,8 @@ func TestLazyLastIndexOf(t *testing.T) { Item: "bar", }, { - In: []string{"foo", "bar", "bar"}, - Item: func (value string) bool { + In: []string{"foo", "bar", "bar"}, + Item: func(value string) bool { return value == "bar" }, }, diff --git a/presence_test.go b/presence_test.go index 95b3144..55705d8 100644 --- a/presence_test.go +++ b/presence_test.go @@ -55,17 +55,17 @@ func TestContains(t *testing.T) { is.True(Contains(mapping, 1)) is.False(Contains(mapping, 2)) - is.False(Contains(mapping, func (key int, val *Foo) bool { + is.False(Contains(mapping, func(key int, val *Foo) bool { return key == 4 })) - is.True(Contains(mapping, func (key int, val *Foo) bool { + is.True(Contains(mapping, func(key int, val *Foo) bool { return key == 1 })) - is.False(Contains(mapping, func (_ int, val *Foo) bool { + is.False(Contains(mapping, func(_ int, val *Foo) bool { return val.FirstName == "NotPresent" })) - is.True(Contains(mapping, func (_ int, val *Foo) bool { + is.True(Contains(mapping, func(_ int, val *Foo) bool { return val.FirstName == "Harald" })) } @@ -103,11 +103,11 @@ func TestSome(t *testing.T) { is.False(Some("zeeshan", "zi", "tam")) persons := []Person{ - Person{ + { name: "Zeeshan", age: 23, }, - Person{ + { name: "Bob", age: 26, }, @@ -131,7 +131,7 @@ func TestIndexOf(t *testing.T) { is := assert.New(t) is.Equal(IndexOf([]string{"foo", "bar"}, "bar"), 1) - is.Equal(IndexOf([]string{"foo", "bar"}, func (value string) bool { + is.Equal(IndexOf([]string{"foo", "bar"}, func(value string) bool { return value == "bar" }), 1) @@ -143,7 +143,7 @@ func TestLastIndexOf(t *testing.T) { is := assert.New(t) is.Equal(LastIndexOf([]string{"foo", "bar", "bar"}, "bar"), 2) - is.Equal(LastIndexOf([]string{"foo", "bar", "bar"}, func (value string) bool { + is.Equal(LastIndexOf([]string{"foo", "bar", "bar"}, func(value string) bool { return value == "bar" }), 2) is.Equal(LastIndexOf([]int{1, 2, 2, 3}, 2), 2)