module EventObject

Define an instance method. `def` is public method.

@param [Symbol] @return [Symbol]

# File lib/event_object/class.rb, line 18
def def(symbol, &b)
  define_method symbol, &b
end

Create events in specified class. For each event we create two methods: `event` and `event!`. `event` returns an array of event listeners. `event!` emits the listeners.

@param [Array] the array of the symbols @return [Symbol]

# File lib/event_object/class.rb, line 9
def events(*ev)
  ev.each { |name| self.def("#{name}!") { |*a, &b| var(name, Array).fire(*a, &b) } }
  ev.map { |name| self.def(name) { var(name, Array) } }
end

Emit event with specified arguments and specified block.

@example

using EventObject
event = [() -> 1, () -> 2]
p event.fire
# [1, 2]

@param *a […] arguments to be passed @param &b [Block] block to be passed @return [Array] the results of the call

# File lib/event_object/array.rb, line 14
def fire(*a, &b)
  dup.map { |h| h.call(*a, &b) }
end

Emit event with specified arguments within the context. It's giving the each listener access to object intance variables. Unlike fire, the block is not allowed.

@param context [Object] the context of the receiver @return [Array]

# File lib/event_object/array.rb, line 24
def instance_fire(context, *a)
  dup.map { |h| context.instance_exec(*a, &h) }
end

Add the `instance` method with `name` like block for the specified event.

@param instance [Object] @param event [Symbol] @param name [Symbol] @return []

# File lib/event_object/object.rb, line 62
def listen(instance, event, name)
  instance.on event, method(name)
end

Removes the specified listener from the array. If no arguments are supplied then all listeners will be removed.

@example

events = [() -> 1, () -> 2]
events.off

@param listener [Proc] listener or nil @return [Proc, Array] listener or nil or array of listeners

# File lib/event_object/array.rb, line 37
def off(listener=nil)
  listener ? delete(listener) : clear
end

Add the `listener` block for the specified `event`. `on` calls can be chained.

@example

class EventEmitter
  using Emmy
  events :success, :error
end
emitter = EventEmitter.new
emitter.on :success do
  [200, {}, "OK"]
end
p emitter.success!

@param event [Symbol] @param listener [Proc] @param block [Block] @return [Proc]

# File lib/event_object/object.rb, line 21
def on(event, listener=nil, &block)
  var(event, Array).tap { |e| e << (listener || block) }; (listener || block)
end

Add the `listener` block for the specified `event`. When event happened `listener` will be removed.

@param event @param listener @param block @return [Proc]

# File lib/event_object/object.rb, line 31
def once(event, listener=nil, &block)
  (ev = nil).tap { |ev|
    var(event, Array).tap { |e| e << (ev = ->(*a) { (listener || block).call(*a); e.delete(ev) }) }
  }
end

Remove all listeners being methods of the `instance`.

@param [] @return []

# File lib/event_object/object.rb, line 70
def stop_listen(instance, event)
  instance.var(event, Array).delete_if { |e| e.is_a?(Method) && e.receiver == self }
end

Get a class variable. If the variable is undefined then the variable will be initialized.

@param symbol [Symbol] the name of the variable @param init […] default value @return […] the value

# File lib/event_object/class.rb, line 27
def var(symbol, init=nil)
  class_variable_defined?(sym = "@#{symbol}") ? class_variable_get(sym) :
  class_variable_set(sym, (init.is_a?(Class) ? init.new : init))
end