From 90375959ece65b4d03ced55d418aac7c23537dfd Mon Sep 17 00:00:00 2001 From: Robin Bastian Date: Sun, 14 Jul 2019 21:07:09 +0700 Subject: [PATCH] More readme & gofmt --- README.md | 97 +++++++++++++++++--- thennable.go | 138 ++++++++++++++--------------- thennable_test.go | 221 ++++++++++++++++++++++++---------------------- 3 files changed, 266 insertions(+), 190 deletions(-) diff --git a/README.md b/README.md index 4c7d29c..4609d0e 100644 --- a/README.md +++ b/README.md @@ -2,12 +2,85 @@ With this package, you can chain a series of functions to build a pipeline -### Example 1 +## Using thennable for error handling / control flow + +Consider the following example + +```go +func main() { + resultOfDoingThis, err := DoThis() + if err != nil { + //log the error + return + } + + resultOfDoingThat err := DoThat(resultOfDoingThis) + if err != nil { + //log the error + return + } + + resultOfDoingAnother err := DoAnother(resultOfDoingThat) + if err != nil { + //log the error + return + } +} +``` + +The above example is the idiomatic way of error handling in go. +Some like it, but most hate it because we need to manually check and return from error one by one. + +Now consider the following example using thennable + +```go +func main() { + result, err := thennable.Start(). + Then(DoThis). + Then(DoThat). + Then(DoAnother). + End() +} +``` + +In the above example, `err` will either be from `DoThis`, `DoThat`, or `DoAnother` function. + +* `DoThat` and `DoAnother` won't be executed if `DoThis` produce an error. +* `DoAnother` won't be executed if `DoThat` produce an error. +* Or you can bypass the error and keep running next function by setting `BreakOnError(true)` in the thennable pipeline. () + +To handle error can either write extra lines like: + +```go + if err != nil { + //log the error + return + } +``` + +or better yet, you can use the built in `Handle` function so the code will looks like: + +```go +func GlobalErrorHandler(err error) { + log.Println(err) +} + +func main() { + result, err := thennable.Start(). + Then(DoThis). + Then(DoThat). + Then(DoAnother). + Handle(GlobalErrorHandler) + End() +} +``` + +## Example 1 ```go import ( "fmt" - "thennable" + thennable "github.com/bastianrob/go-thennable" ) func AddOne(num int) (int, error) { @@ -16,9 +89,9 @@ func AddOne(num int) (int, error) { func Decide(num int) (string, error) { if num == 1 { - return "one" + return "one", nil else { - return "not one" + return "not one", nil } } @@ -33,12 +106,12 @@ func main() { } ``` -### Example 2: Inlining +## Example 2: Inlining ```go import ( "fmt" - "thennable" + thennable "github.com/bastianrob/go-thennable" ) func main() { @@ -55,13 +128,13 @@ func main() { } ``` -### Example 3: Error Occurred +## Example 3: Error Occurred ```go import ( "fmt" "errors" - "thennable" + thennable "github.com/bastianrob/go-thennable" ) func AddOne(num int) (int, error) { @@ -83,14 +156,13 @@ func main() { } ``` - -### Example 4: Recover from error +## Example 4: Recover from error ```go import ( "fmt" "errors" - "thennable" + thennable "github.com/bastianrob/go-thennable" ) func AddOne(num int) (int, error) { @@ -108,9 +180,8 @@ func main() { Then(AddOne). //8 + 1 Then(AddOne). //9 + 1 End() - + fmt.Printf("Res: %v, Str: %s, Err: %v", result, str, err) //Res: [10], Err: nil } ``` - diff --git a/thennable.go b/thennable.go index 4723a02..b64a3c9 100644 --- a/thennable.go +++ b/thennable.go @@ -1,13 +1,14 @@ package thennable import ( - "errors" - "reflect" + "errors" + "reflect" ) +//Error collection var ( - ErrNotFunction = errors.New("Argument supplied must be a function") - ErrNoErrorHandling = errors.New("Function last return value must be an error") + ErrNotFunction = errors.New("Argument supplied must be a function") + ErrNoErrorHandling = errors.New("Function last return value must be an error") ) /* @@ -15,11 +16,11 @@ IThennable is an interface for thennable The main purpose to to be able to chain execution of functions */ type IThennable interface { - BreakOnError(bool) IThennable - Supply(...interface{}) IThennable - Then(interface{}) IThennable - Handle(FErrorHandler) IThennable - End() ([]interface{}, error) + BreakOnError(bool) IThennable + Supply(...interface{}) IThennable + Then(interface{}) IThennable + Handle(FErrorHandler) IThennable + End() ([]interface{}, error) } //FErrorHandler function @@ -27,90 +28,89 @@ type FErrorHandler func(error) //private implementation of IThennable type thennable struct { - throw error - state []reflect.Value - runnable reflect.Value - breakOnError bool + throw error + state []reflect.Value + runnable reflect.Value + breakOnError bool } //Start creating a new IThennable with and initial value/state func Start(params ...interface{}) IThennable { - state := []reflect.Value{} - for _, param := range params { - state = append(state, reflect.ValueOf(param)) - } - return &thennable{state: state, breakOnError: true} + state := []reflect.Value{} + for _, param := range params { + state = append(state, reflect.ValueOf(param)) + } + return &thennable{state: state, breakOnError: true} } //Runnable function is a function that have at least error return value func newRunnable(fn interface{}) (runnable reflect.Value, err error) { - t := reflect.TypeOf(fn) - if t.Kind() != reflect.Func { - return runnable, ErrNotFunction - } - - out := t.NumOut() - if out <= 0 || t.Out(out-1).Name() != "error" { - return runnable, ErrNoErrorHandling - } - - return reflect.ValueOf(fn), nil -} + t := reflect.TypeOf(fn) + if t.Kind() != reflect.Func { + return runnable, ErrNotFunction + } + + out := t.NumOut() + if out <= 0 || t.Out(out-1).Name() != "error" { + return runnable, ErrNoErrorHandling + } + return reflect.ValueOf(fn), nil +} //BreakOnError stops function chaining when error occured func (tnb *thennable) BreakOnError(breakOnError bool) IThennable { - tnb.breakOnError = breakOnError - return tnb + tnb.breakOnError = breakOnError + return tnb } //Supply next runnable function with a value func (tnb *thennable) Supply(params ...interface{}) IThennable { - state := []reflect.Value{} - for _, param := range params { - state = append(state, reflect.ValueOf(param)) - } - - return &thennable{state: state, breakOnError: tnb.breakOnError} + state := []reflect.Value{} + for _, param := range params { + state = append(state, reflect.ValueOf(param)) + } + + return &thennable{state: state, breakOnError: tnb.breakOnError} } func (tnb *thennable) Then(next interface{}) IThennable { - if tnb.breakOnError && tnb.throw != nil { - return tnb - } - - //if not runnable func - runnable, err := newRunnable(next) - if err != nil { - tnb.state, tnb.throw = make([]reflect.Value, 0), err - return tnb - } - - //else - result := runnable.Call(tnb.state) - retCount := len(result) - errIdx := retCount - 1 - - tnb.state, tnb.throw = result[0:errIdx], nil - lastOutput := result[errIdx].Interface() - if lastOutput != nil { - tnb.throw = lastOutput.(error) - } - - return tnb + if tnb.breakOnError && tnb.throw != nil { + return tnb + } + + //if not runnable func + runnable, err := newRunnable(next) + if err != nil { + tnb.state, tnb.throw = make([]reflect.Value, 0), err + return tnb + } + + //else + result := runnable.Call(tnb.state) + retCount := len(result) + errIdx := retCount - 1 + + tnb.state, tnb.throw = result[0:errIdx], nil + lastOutput := result[errIdx].Interface() + if lastOutput != nil { + tnb.throw = lastOutput.(error) + } + + return tnb } //Handle error func (tnb *thennable) Handle(handle FErrorHandler) IThennable { - handle(tnb.throw) - return tnb + handle(tnb.throw) + return tnb } //End execution and collect the result func (tnb *thennable) End() ([]interface{}, error) { - end := make([]interface{}, 0) - for _, state := range tnb.state { - end = append(end, state.Interface()) - } - return end, tnb.throw -} \ No newline at end of file + end := make([]interface{}, 0) + for _, state := range tnb.state { + end = append(end, state.Interface()) + } + return end, tnb.throw +} diff --git a/thennable_test.go b/thennable_test.go index 21c9b5c..d98657b 100644 --- a/thennable_test.go +++ b/thennable_test.go @@ -1,122 +1,127 @@ package thennable_test import ( - "fmt" - "strconv" - "thennable" - "testing" + "fmt" + "strconv" + "testing" + + thennable "github.com/bastianrob/go-thennable" ) func AddOne(val int) (int, error) { - return val + 1, nil + return val + 1, nil } -func Throwable(val interface{}) (error) { - return fmt.Errorf("Exception occurred with supplied value: %+v", val) +func Throwable(val interface{}) error { + return fmt.Errorf("Exception occurred with supplied value: %+v", val) } func LogError(err error) { - fmt.Printf("Log Error: %+v\n", err) + fmt.Printf("Log Error: %+v\n", err) } func Test_IThennable(t *testing.T) { - fmt.Println("\nStarting Test_IThennable.go") - - addOne := AddOne - throw := Throwable - - //Test 1 - fmt.Println("Start Test 1: Expect result = 5 and err is nil") - result, err := thennable.Start(1).//starts with 1 - Then(addOne). //add 1 with 1 = 2 - Then(addOne). //result = 3 - Then(addOne). //result = 4 - Then(addOne). //result = 5 - End() - - if result[0].(int) != 5 { - t.Errorf("Test 1 result should be = 5, actual value: %d", result[0]) - } - if err != nil { - t.Errorf("Test 1 error should be = nil, actual value: %+v", err) - } - - //Test 2 - fmt.Println("\nStart Test 2: Expect result is nil and err is not nil") - result, err = thennable.Start(1).//starts with 1 - Then(addOne). //add 1 with 1 = 2 - Then(addOne). //add 2 with 1 = 3 - Then(throw). //err = exception - Handle(LogError). - Then(addOne). //skipped - Then(addOne). //skipped - End() - - if len(result) != 0 { - t.Errorf("Test 2 result should be = empty, actual value: %d", len(result)) - } - if err == nil { - t.Errorf("Test 2 error should not be = nil, actual value: %+v", err) - } - - //Test 3 - fmt.Println("\nStart Test 3: Expect result = 2 and err is nil") - result, err = thennable.Start(1).//starts with 1 - BreakOnError(false). //keep propagating the function chain - Then(addOne). //add 1 with 1 = 2 - Then(addOne). //result = 3 - Then(throw). //result = 0, err = exception ignored - Supply(0). //resupply with 0 - Then(addOne). //add 0 with 1 = 1, err = nil - Then(addOne). //result = 2, err = nil - End() - - if result[0].(int) != 2 { - t.Errorf("Test 3 result should be = 2, actual value: %d", result[0]) - } - if err != nil { - t.Errorf("Test 3 error should be = nil, actual value: %+v", err) - } - - //Test 4 - fmt.Println("\nStart Test 4: Expect recover from error, result is 10 and err is nil") - result, err = thennable.Start(1).//starts with 1 - Then(addOne). //add 1 with 1 = 2 - Then(throw). //result = nil, err = exception - Then(addOne). //skipped - Handle(LogError). //log the error - BreakOnError(false). //recover from error - Supply(8). //resuply the value with 8 - Then(addOne). //result = 9 - Then(addOne). //result = 10 - Handle(LogError). //log error should be nil - End() - - if result[0].(int) != 10 { - t.Errorf("Test 4 result should be = 10, actual value: %d", result[0]) - } - if err != nil { - t.Errorf("Test 4 error should be nil, actual value: %+v", err) - } - - //Test 5 - fmt.Println("\nStart Test 5: Expect result is '6' and err is nil") - result, err = thennable.Start(1). - Then(func (one int) (int, int, error) { - return one, 2, nil - }). - Then(func (one, two int) (int, int, int, error) { - return one, two, 3, nil - }). - Then(func (one, two, three int) (string, error) { - return strconv.Itoa(one + two + three), nil - }). - End() - - if result[0].(string) != "6" { - t.Errorf("Test 5 result should be = '6', actual value: %v\n", result) - } - if err != nil { - t.Errorf("Test 5 error should be nil, actual value: %+v\n", err) - } -} \ No newline at end of file + fmt.Println("\nStarting Test_IThennable.go") + + addOne := AddOne + throw := Throwable + + //Test 1 + fmt.Println("Start Test 1: Expect result = 5 and err is nil") + result, err := thennable. + Start(1). //starts with 1 + Then(addOne). //add 1 with 1 = 2 + Then(addOne). //result = 3 + Then(addOne). //result = 4 + Then(addOne). //result = 5 + End() + + if result[0].(int) != 5 { + t.Errorf("Test 1 result should be = 5, actual value: %d", result[0]) + } + if err != nil { + t.Errorf("Test 1 error should be = nil, actual value: %+v", err) + } + + //Test 2 + fmt.Println("\nStart Test 2: Expect result is nil and err is not nil") + result, err = thennable. + Start(1). //starts with 1 + Then(addOne). //add 1 with 1 = 2 + Then(addOne). //add 2 with 1 = 3 + Then(throw). //err = exception + Handle(LogError). + Then(addOne). //skipped + Then(addOne). //skipped + End() + + if len(result) != 0 { + t.Errorf("Test 2 result should be = empty, actual value: %d", len(result)) + } + if err == nil { + t.Errorf("Test 2 error should not be = nil, actual value: %+v", err) + } + + //Test 3 + fmt.Println("\nStart Test 3: Expect result = 2 and err is nil") + result, err = thennable. + Start(1). //starts with 1 + BreakOnError(false). //keep propagating the function chain + Then(addOne). //add 1 with 1 = 2 + Then(addOne). //result = 3 + Then(throw). //result = 0, err = exception ignored + Supply(0). //resupply with 0 + Then(addOne). //add 0 with 1 = 1, err = nil + Then(addOne). //result = 2, err = nil + End() + + if result[0].(int) != 2 { + t.Errorf("Test 3 result should be = 2, actual value: %d", result[0]) + } + if err != nil { + t.Errorf("Test 3 error should be = nil, actual value: %+v", err) + } + + //Test 4 + fmt.Println("\nStart Test 4: Expect recover from error, result is 10 and err is nil") + result, err = thennable. + Start(1). //starts with 1 + Then(addOne). //add 1 with 1 = 2 + Then(throw). //result = nil, err = exception + Then(addOne). //skipped + Handle(LogError). //log the error + BreakOnError(false). //recover from error + Supply(8). //resuply the value with 8 + Then(addOne). //result = 9 + Then(addOne). //result = 10 + Handle(LogError). //log error should be nil + End() + + if result[0].(int) != 10 { + t.Errorf("Test 4 result should be = 10, actual value: %d", result[0]) + } + if err != nil { + t.Errorf("Test 4 error should be nil, actual value: %+v", err) + } + + //Test 5 + fmt.Println("\nStart Test 5: Expect result is '6' and err is nil") + result, err = thennable.Start(1). + Then(func(one int) (int, int, error) { + return one, 2, nil + }). + Then(func(one, two int) (int, int, int, error) { + return one, two, 3, nil + }). + Then(func(one, two, three int) (string, error) { + return strconv.Itoa(one + two + three), nil + }). + End() + + if result[0].(string) != "6" { + t.Errorf("Test 5 result should be = '6', actual value: %v\n", result) + } + if err != nil { + t.Errorf("Test 5 error should be nil, actual value: %+v\n", err) + } +}