Merge pull request #22 from donutloop/feat/hooks

- Added: Simple hook implementation

Author: donutloop

event/README.md

@@ -0,0 +1,24 @@
+# Usage
+
+Hooks holds a list of functions (func error) to call whenever the set is
+triggered.
+
+## Example 
+```go 
+package main 
+
+import (
+	"github.com/donutloop/toolkit/event"
+)
+
+func main() {
+    hooks := new(event.Hooks)
+    hooks.Add(func() { 
+    	// do things
+    })
+    hooks.Add(func() { 
+        // do things 
+    })
+    hooks.Fire()
+}
+```

event/hook.go

@@ -0,0 +1,52 @@
+package event
+
+import (
+	"fmt"
+	"sync"
+)
+
+// Hooks holds a list of parameter-less functions to call whenever the set is
+// triggered with Fire().
+type Hooks struct {
+	funcs []func()
+	mu    sync.Mutex
+	wg    sync.WaitGroup
+}
+
+func (h *Hooks) Add(f func()) {
+	h.mu.Lock()
+	h.funcs = append(h.funcs, f)
+	h.mu.Unlock()
+}
+
+// Fire calls all the functions in a given Hooks list. It launches a goroutine
+// for each function and then waits for all of them to finish before returning.
+func (h *Hooks) Fire() []error {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
+	errc := make(chan error, len(h.funcs))
+	for _, hook := range h.funcs {
+		h.wg.Add(1)
+		go hookWrapper(&h.wg, hook, errc)
+	}
+
+	h.wg.Wait()
+	close(errc)
+	errs := make([]error, 0, len(h.funcs))
+	for err := range errc {
+		errs = append(errs, err)
+	}
+	return errs
+}
+
+func hookWrapper(wg *sync.WaitGroup, hook func(), errc chan error) {
+	defer func() {
+		if v := recover(); v != nil {
+			errc <- fmt.Errorf("hook is panicked (%v)", v)
+		}
+		wg.Done()
+	}()
+
+	hook()
+}

event/hook_test.go

@@ -0,0 +1,62 @@
+package event_test
+
+import (
+	"github.com/donutloop/toolkit/event"
+	"testing"
+)
+
+func TestHooksMultiFire(t *testing.T) {
+	hooks := new(event.Hooks)
+	hooks.Add(func() {})
+	hooks.Add(func() {})
+
+	for i := 0; i < 10; i++ {
+		errs := hooks.Fire()
+		if len(errs) > 0 {
+			for _, err := range errs {
+				t.Error(err)
+			}
+		}
+	}
+}
+
+func TestHooks(t *testing.T) {
+	triggered1 := false
+	triggered2 := false
+
+	hooks := new(event.Hooks)
+	hooks.Add(func() { triggered1 = true })
+	hooks.Add(func() { triggered2 = true })
+
+	hooks.Fire()
+
+	if !triggered1 {
+		t.Errorf("registered (first) hook function failed to trigger")
+	}
+
+	if !triggered2 {
+		t.Errorf("registered (second) hook function failed to trigger")
+	}
+}
+
+func TestHooksPanic(t *testing.T) {
+	hooks := new(event.Hooks)
+	hooks.Add(func() { panic("check isolation of goroutine") })
+	errs := hooks.Fire()
+	if len(errs) != 1 {
+		t.Fatalf("error count is bad (%d)", len(errs))
+	}
+
+	expectedMessage := "hook is panicked (check isolation of goroutine)"
+	if errs[0].Error() != expectedMessage {
+		t.Fatalf(`unexpected error message (actual: "%s", expected: "%s")`, errs[0].Error(), expectedMessage)
+	}
+}
+
+func BenchmarkHooks(b *testing.B) {
+	hooks := new(event.Hooks)
+	hooks.Add(func() {})
+	for n := 0; n < b.N; n++ {
+		hooks.Fire()
+	}
+}