Merge pull request #15 from pearl2201/master

Add All and Every function

Author: dineshba

README.md

@@ -20,6 +20,7 @@ Inspired from [Lodash](https://github.com/lodash/lodash) for golang
 3. [Reduce](#Reduce)
 4. [Any](#Any-or-Some) or [Some](#Any-or-Some)
 5. [Find](#Find)
+6. [All](#All-or-Every) or [Every](#All-or-Every)
 
 ## Usages
 
@@ -150,15 +151,14 @@ func main() {
 Any or Some checks if predicate returns truthy for any element of collection. Iteration is stopped once predicate returns truthy.
 For more [docs](https://godoc.org/github.com/thecasualcoder/godash#Any).
 
+
 ```go
 func main() {
 	input := []int{1, 2, 3, 4, 5}
 	var output []int
-
 	output, _ := godash.Any(input, func(num int) bool {
 		return num % 7 == 0
 	})
-
 	fmt.Println(output) // prints false
 }
 ```
@@ -170,15 +170,14 @@ func main() {
 		{Name: "Doe", Age: 15},
 	}
 	var output int
-
 	output, _ := godash.Some(input, func(person Person) bool {
 		return person.Age < 18
 	})
-
 	fmt.Println(output) // prints true
 }
 ```
 
+
 ### Find
 
 Returns the first element which passes the predicate.
@@ -194,4 +193,33 @@ func main() {
 	// output is "wick"
 	fmt.Println(output)
 }
-```
+```
+
+### All or Every 
+
+All or Every checks if predicate returns truthy for all element of collection. Iteration is stopped once predicate returns falsely. 
+For more [docs](https://godoc.org/github.com/thecasualcoder/godash#All). 
+
+```go 
+func main() { 
+	input := []int{1, 2, 3, 4, 5} 
+	var output bool 
+	output, _ := godash.All(input, func(num int) bool { 
+		return num >= 1 
+	}) 
+	fmt.Println(output) // prints true 
+} 
+``` 
+
+```go 
+func main() { 
+	input := []Person{ 
+		{Name: "John", Age: 25}, 
+		{Name: "Doe", Age: 15}, 
+	} 
+	var output bool 
+	output, _ := godash.Every(input, func(person Person) bool {
+		return person.Age < 18 
+	}) 
+	fmt.Println(output) // prints false 
+}

all.go

@@ -0,0 +1,65 @@
+package godash
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// All checks if predicate returns truthy for all element of collection. Iteration is stopped once predicate returns falsely.
+// Currently, input of type slice is supported
+//
+// Validations:
+//
+// 1. Predicate function should take one argument and return one value
+// 2. Predicate function should return a bool value
+// 3. Predicate function's argument should be of the same type as the elements of the input slice
+//
+// Validation errors are returned to the caller
+func All(in, predicateFn interface{}) (bool, error) {
+
+	input := reflect.ValueOf(in)
+	predicate := reflect.ValueOf(predicateFn)
+
+	if predicate.Kind() != reflect.Func {
+		return false, fmt.Errorf("predicateFn has to be a function")
+	}
+
+	predicateFnType := predicate.Type()
+	if predicateFnType.NumIn() != 1 {
+		return false, fmt.Errorf("predicate function has to take only one argument")
+	}
+
+	if predicateFnType.NumOut() != 1 {
+		return false, fmt.Errorf("predicate function should return only one return value")
+	}
+
+	if predicateFnType.Out(0).Kind() != reflect.Bool {
+		return false, fmt.Errorf("predicate function should return a boolean value")
+	}
+
+	inputKind := input.Kind()
+	if inputKind == reflect.Slice {
+		inputSliceElemType := input.Type().Elem
+		predicateFnArgType := predicateFnType.In(0)
+		if inputSliceElemType() != predicateFnArgType {
+			return false, fmt.Errorf("predicate function's argument (%s) has to be (%s)", predicateFnArgType, inputSliceElemType())
+		}
+
+		for i := 0; i < input.Len(); i++ {
+			arg := input.Index(i)
+			returnValue := predicate.Call([]reflect.Value{arg})[0]
+			if !returnValue.Bool() {
+				return false, nil
+			}
+		}
+
+		return true, nil
+	}
+
+	return false, fmt.Errorf("not implemented for (%s)", inputKind)
+}
+
+// Every is an alias for All function
+func Every(in, predicateFn interface{}) (bool, error) {
+	return All(in, predicateFn)
+}

all_test.go

@@ -0,0 +1,147 @@
+package godash_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thecasualcoder/godash"
+)
+
+func TestAllAndEvery(t *testing.T) {
+	var funcs = map[string]func(interface{}, interface{}) (bool, error){
+		"All()":   godash.All,
+		"Every()": godash.Every,
+	}
+
+	for fnName, fn := range funcs {
+		t.Run(fmt.Sprintf("%s should return err if predicate is not a function", fnName), func(t *testing.T) {
+			in := []int{1, 2, 3}
+
+			_, err := fn(in, "not a func")
+
+			assert.EqualError(t, err, "predicateFn has to be a function")
+		})
+
+		t.Run(fmt.Sprintf("%s should return err if predicate function do not take exactly one argument", fnName), func(t *testing.T) {
+			in := []int{1, 2, 3}
+
+			{
+				_, err := fn(in, func() {})
+
+				assert.EqualError(t, err, "predicate function has to take only one argument")
+			}
+			{
+				_, err := fn(in, func(int, int) {})
+
+				assert.EqualError(t, err, "predicate function has to take only one argument")
+			}
+		})
+
+		t.Run(fmt.Sprintf("%s should return err if predicate function do not return exactly one value", fnName), func(t *testing.T) {
+			in := []int{1, 2, 3}
+
+			{
+				_, err := fn(in, func(int) {})
+
+				assert.EqualError(t, err, "predicate function should return only one return value")
+			}
+			{
+				_, err := fn(in, func(int) (bool, bool) { return true, true })
+
+				assert.EqualError(t, err, "predicate function should return only one return value")
+
+			}
+		})
+
+		t.Run(fmt.Sprintf("%s should return err if predicate function's return value is not a boolean", fnName), func(t *testing.T) {
+			in := []int{1, 2, 3}
+
+			_, err := fn(in, func(int) int { return 0 })
+
+			assert.EqualError(t, err, "predicate function should return a boolean value")
+		})
+
+		t.Run(fmt.Sprintf("%s should return err if input is not a slice", fnName), func(t *testing.T) {
+			in := 1
+
+			_, err := fn(in, func(int) bool { return true })
+
+			assert.EqualError(t, err, "not implemented for (int)")
+		})
+
+		t.Run(fmt.Sprintf("%s should return err if there is a type mismatch between predicate function's argument and input slice", fnName), func(t *testing.T) {
+			in := []string{"hello", "world"}
+
+			_, err := fn(in, func(int) bool { return true })
+
+			assert.EqualError(t, err, "predicate function's argument (int) has to be (string)")
+		})
+
+		t.Run(fmt.Sprintf("%s should return true if predicate passes for all element in input slice", fnName), func(t *testing.T) {
+			in := []int{1, 3, 5, 7, 9, 11, 13}
+
+			output, err := fn(in, func(elem int) bool { return elem%2 == 1 })
+
+			assert.NoError(t, err)
+			assert.True(t, output)
+		})
+
+		t.Run(fmt.Sprintf("%s should return false if predicate fails for at least one of the elements in input slice", fnName), func(t *testing.T) {
+			in := []int{1, 2, 5, 7, 9, 11, 13}
+
+			output, err := fn(in, func(num int) bool { return num%2 == 1 })
+
+			assert.NoError(t, err)
+			assert.False(t, output)
+		})
+
+		t.Run(fmt.Sprintf("%s should support structs", fnName), func(t *testing.T) {
+			type person struct {
+				name string
+				age  int
+			}
+			in := []person{
+				{name: "John", age: 12},
+				{name: "Doe", age: 25},
+			}
+
+			{
+				output, err := fn(in, func(person person) bool { return person.age < 18 })
+
+				assert.NoError(t, err)
+				assert.False(t, output)
+			}
+			{
+				output, err := fn(in, func(person person) bool { return person.age < 30 })
+
+				assert.NoError(t, err)
+				assert.True(t, output)
+			}
+		})
+	}
+}
+
+func ExampleAll() {
+	input := []int{0, 1, 2, 3, 4}
+
+	output, _ := godash.All(input, func(num int) bool {
+		return num >= 0
+	})
+
+	fmt.Println(output)
+
+	// Output: true
+}
+
+func ExampleEvery() {
+	input := []int{0, 1, 2, 3, 4}
+
+	output, _ := godash.Every(input, func(num int) bool {
+		return num >= 0
+	})
+
+	fmt.Println(output)
+
+	// Output: true
+}