refactor event emit to accept variadic args

app.go

@@ -270,9 +270,9 @@ func NewMsg(key string) Msg {
 	return &msg{key: key}
 }
 
-// Emit emits the event with the given value.
-func Emit(e Event, value interface{}) {
-	events.Emit(e, value)
+// Emit emits the event with the given arguments.
+func Emit(e Event, args ...interface{}) {
+	events.Emit(e, args...)
 }
 
 // NewSubscriber creates an event subscriber to return when implementing the

app_test.go

@@ -55,7 +55,7 @@ func TestApp(t *testing.T) {
 		assert.NotNil(t, app.Dock())
 		assert.NotNil(t, app.NewStatusMenu(app.StatusMenuConfig{}))
 
-		app.Emit("test", nil)
+		app.Emit("test")
 
 		app.UI(func() {
 			app.Logf("hello")

drivers/mac/driver_darwin.go

@@ -279,17 +279,17 @@ func (d *Driver) onRun(in map[string]interface{}) interface{} {
 		app.NewWindow(d.DefaultWindow)
 	}
 
-	d.events.Emit(app.Running, nil)
+	d.events.Emit(app.Running)
 	return nil
 }
 
 func (d *Driver) onFocus(in map[string]interface{}) interface{} {
-	d.events.Emit(app.Focused, nil)
+	d.events.Emit(app.Focused)
 	return nil
 }
 
 func (d *Driver) onBlur(in map[string]interface{}) interface{} {
-	d.events.Emit(app.Blurred, nil)
+	d.events.Emit(app.Blurred)
 	return nil
 }
 
@@ -300,7 +300,7 @@ func (d *Driver) onReopen(in map[string]interface{}) interface{} {
 		app.NewWindow(d.DefaultWindow)
 	}
 
-	d.events.Emit(app.Reopened, nil)
+	d.events.Emit(app.Reopened)
 	return nil
 }
 
@@ -323,7 +323,7 @@ func (d *Driver) onFileDrop(in map[string]interface{}) interface{} {
 }
 
 func (d *Driver) onClose(in map[string]interface{}) interface{} {
-	d.events.Emit(app.Closed, nil)
+	d.events.Emit(app.Closed)
 
 	d.UI(func() {
 		d.stop()

drivers/mac/menubar.go

@@ -123,7 +123,7 @@ func (m *AppMenu) Render() string {
 
 // OnPreferences is the function called when the Preferences button is clicked.
 func (m *AppMenu) OnPreferences() {
-	app.Emit(PreferencesRequested, nil)
+	app.Emit(PreferencesRequested)
 }
 
 // EditMenu is a component that describes the default edit menu.

drivers/test/driver.go

@@ -41,7 +41,7 @@ func (d *Driver) Run(c app.DriverConfig) error {
 	defer cancel()
 	d.stop = cancel
 
-	d.events.Emit(app.Running, nil)
+	d.events.Emit(app.Running)
 
 	for {
 		select {

event.go

@@ -21,8 +21,10 @@ type Subscriber struct {
 	unsuscribes []func()
 }
 
-// Subscribe subscribes a function to the given key.
-// It panics if f is not a func.
+// Subscribe subscribes a function to the given event. Emit fails if the
+// subscribbed func have more arguments than the emitted event.
+//
+// Panics if f is not a func.
 func (s *Subscriber) Subscribe(e Event, f interface{}) *Subscriber {
 	unsubscribe := s.Events.subscribe(e, f)
 	s.unsuscribes = append(s.unsuscribes, unsubscribe)
@@ -101,37 +103,42 @@ func (r *EventRegistry) unsubscribe(e Event, id string) {
 	}
 }
 
-// Emit emits the event with the given value.
-func (r *EventRegistry) Emit(e Event, v interface{}) {
+// Emit emits the event with the given arguments.
+func (r *EventRegistry) Emit(e Event, args ...interface{}) {
 	r.mutex.RLock()
 	defer r.mutex.RUnlock()
 
 	for _, h := range r.handlers[e] {
-		val := reflect.ValueOf(h.Handler)
-		typ := val.Type()
-
-		if typ.NumIn() == 0 {
-			r.ui <- func() {
-				val.Call(nil)
-			}
-			return
+		if err := r.callHandler(h.Handler, args...); err != nil {
+			Log("emitting %s failed: %s", e, err)
 		}
+	}
+}
 
-		argVal := reflect.ValueOf(v)
-		argTyp := typ.In(0)
+func (r *EventRegistry) callHandler(h interface{}, args ...interface{}) error {
+	v := reflect.ValueOf(h)
+	t := v.Type()
 
-		if !argVal.Type().ConvertibleTo(argTyp) {
-			Log("dispatching event %s failed: %s",
-				e,
-				errors.Errorf("can't convert %s to %s", argVal.Type(), argTyp),
-			)
-			return
+	argsv := make([]reflect.Value, t.NumIn())
+
+	for i := 0; i < t.NumIn(); i++ {
+		argt := t.In(i)
+
+		if i >= len(args) {
+			return errors.Errorf("missing %v at index %v", argt, i)
 		}
 
-		r.ui <- func() {
-			val.Call([]reflect.Value{
-				argVal.Convert(argTyp),
-			})
+		argv := reflect.ValueOf(args[i])
+		if !argv.Type().ConvertibleTo(argt) {
+			return errors.Errorf("arg at index %v is not a %v: %v", i, argt, argv.Type())
 		}
+
+		argsv[i] = argv.Convert(argt)
 	}
+
+	r.ui <- func() {
+		v.Call(argsv)
+	}
+
+	return nil
 }

event_test.go

@@ -23,7 +23,7 @@ func TestEventRegistry(t *testing.T) {
 		panic    bool
 	}{
 		{
-			scenario: "register and dispatch without arg",
+			scenario: "register and emit without arg",
 			subName:  "test",
 			handler: func(called *bool) interface{} {
 				return func() {
@@ -35,7 +35,7 @@ func TestEventRegistry(t *testing.T) {
 			dispArg:  nil,
 		},
 		{
-			scenario: "register without arg and dispatch with arg",
+			scenario: "register without arg and emit with arg",
 			subName:  "test",
 			handler: func(called *bool) interface{} {
 				return func() {
@@ -47,7 +47,7 @@ func TestEventRegistry(t *testing.T) {
 			dispArg:  "foobar",
 		},
 		{
-			scenario: "register and dispatch with arg",
+			scenario: "register and emit with arg",
 			subName:  "test",
 			handler: func(called *bool) interface{} {
 				return func(arg string) {
@@ -63,7 +63,19 @@ func TestEventRegistry(t *testing.T) {
 			dispArg:  "hello",
 		},
 		{
-			scenario: "register and dispatch with bad arg",
+			scenario: "register and emit without enough args",
+			subName:  "test",
+			handler: func(called *bool) interface{} {
+				return func(string, bool) {
+					*called = true
+				}
+			},
+			called:   false,
+			dispName: "test",
+			dispArg:  "hello",
+		},
+		{
+			scenario: "register and emit with bad arg",
 			subName:  "test",
 			handler: func(called *bool) interface{} {
 				return func(arg int) {

internal/core/driver_test.go

@@ -9,6 +9,8 @@ import (
 )
 
 func TestDriver(t *testing.T) {
+	app.Logger = t.Logf
+
 	d := &Driver{}
 	require.Implements(t, (*app.Driver)(nil), d)