Initial commit

README.md

@@ -0,0 +1,5 @@
+Event
+==========
+
+Really simple event Bus
+

bus.go

@@ -0,0 +1,40 @@
+package event
+
+// Should be called manager?
+
+// Bus can be implemente in other sturcts
+type Bus interface {
+	Emitter
+	Receiver
+}
+
+// EventBus implementation
+type eventBus struct {
+	handlers map[string]*[]HandlerFunc
+}
+
+// NewBus Creates and Initializes an eventBus
+func NewBus() Bus {
+	return &eventBus{handlers: map[string]*[]HandlerFunc{}}
+}
+func (e *eventBus) Emit(evt Event) {
+	handlerList, ok := e.handlers[evt.Name()]
+	if !ok {
+		return
+	}
+	for _, handler := range *handlerList {
+		handler(evt)
+	}
+
+}
+
+func (e *eventBus) On(name string, handler HandlerFunc) {
+	handlerList, ok := e.handlers[name]
+	if !ok {
+		handlerList = &[]HandlerFunc{}
+		e.handlers[name] = handlerList
+	}
+
+	*handlerList = append(*handlerList, handler)
+
+}

event.go

@@ -0,0 +1,62 @@
+package event
+
+const (
+	namedPrefixer = ":"
+)
+
+// Emitter able to emit events
+type Emitter interface {
+	Emit(Event)
+}
+
+// Receiver able to listen to events
+type Receiver interface {
+	On(name string, handler HandlerFunc)
+}
+
+// HandlerFunc func
+type HandlerFunc func(Event)
+
+// Event specific interface
+type Event interface {
+	Name() string
+	Data() interface{}
+}
+
+// private data
+type event struct {
+	name string
+	data interface{}
+}
+
+// New Event
+func New(name string, data interface{}) Event {
+	return &event{name, data}
+}
+
+func (e *event) Name() string {
+	return e.name
+}
+
+func (e *event) Data() interface{} {
+	return e.data
+}
+
+// Prefixer
+
+// NamedEmitter data for event prefixer
+type NamedEmitter struct {
+	name string
+	bus  Bus
+}
+
+// NewNamedEmitter creates a new emitter pointing to bus
+func NewNamedEmitter(name string, bus Bus) Emitter {
+	return &NamedEmitter{name, bus}
+}
+
+// Emit will prefix with namedemitter name and push to bus
+func (ne *NamedEmitter) Emit(evt Event) {
+	newEvt := &event{name: ne.name + namedPrefixer + evt.Name(), data: evt.Data()}
+	ne.bus.Emit(newEvt)
+}

event_test.go

@@ -0,0 +1,78 @@
+package event_test
+
+import (
+	"testing"
+
+	"dev.hexasoftware.com/hxs/event"
+)
+
+func TestEvent(t *testing.T) {
+
+	bus := event.NewBus()
+	a := 0
+	bus.On("test", func(evt event.Event) {
+		t.Log("Event successfull")
+		a++
+	})
+
+	bus.Emit(event.New("test", nil))
+
+	if a != 1 {
+		t.Fatal("Event Failed")
+	}
+
+}
+
+// Testing a named emitter that prefixes events
+func TestNamedEmitter(t *testing.T) {
+
+	bus := event.NewBus()
+
+	em := event.NewNamedEmitter("user", bus)
+
+	a := 0
+
+	bus.On("test", func(evt event.Event) {
+		a++
+	})
+
+	bus.On("user:test", func(evt event.Event) {
+		t.Log("Event fired successfully")
+		a++
+	})
+
+	em.Emit(event.New("test", nil))
+	if a != 1 {
+		t.Fail()
+	}
+}
+
+type MyStruct struct {
+	event.Emitter
+}
+
+func TestCustomStruct(t *testing.T) {
+	bus := event.NewBus()
+	a := 0
+
+	bus.On("MyStruct:test", func(evt event.Event) {
+		t.Log("Event fired successfully")
+		a++
+	})
+
+	s := MyStruct{event.NewNamedEmitter("MyStruct", bus)}
+
+	s.Emit(event.New("test", nil))
+
+}
+
+func TestParamData(t *testing.T) {
+	bus := event.NewBus()
+	bus.On("test", func(evt event.Event) {
+		str := evt.Data().(string)
+		if str != "123" {
+			t.FailNow()
+		}
+	})
+	bus.Emit(event.New("test", "123"))
+}