feat(event): add support for event emitter

event emitter support added, with optionally bind generator methods

Author: thetutlage

lib/util.js

@@ -9,9 +9,14 @@
  * file that was distributed with this source code.
 */
 
-const util = exports = module.exports = {}
 const _ = require('lodash')
 
+const toStr = Object.prototype.toString
+const fnToStr = Function.prototype.toString
+const isFnRegex = /^\s*(?:function)?\*/
+
+const util = exports = module.exports = {}
+
 /**
  * tells whether value exists or not by checking
  * it type
@@ -37,3 +42,20 @@ util.existy = function (value) {
 util.spread = function () {
   return _.isArray(arguments[0]) ? arguments[0] : _.toArray(arguments)
 }
+
+/**
+ * tells whether a method is a genetator function or
+ * not
+ *
+ * @method isGenerator
+ *
+ * @param  {Function}    method
+ * @return {Boolean}
+ *
+ * @private
+ */
+util.isGenerator = function (method) {
+  const viaToStr = toStr.call(method)
+  const viaFnToStr = fnToStr.call(method)
+  return (viaToStr === '[object Function]' || viaToStr === '[object GeneratorFunction]') && isFnRegex.test(viaFnToStr)
+}

providers/EventProvider.js

@@ -0,0 +1,22 @@
+'use strict'
+
+/**
+ * adonis-framework
+ * Copyright(c) 2015-2016 Harminder Virk
+ * MIT Licensed
+*/
+
+const ServiceProvider = require('adonis-fold').ServiceProvider
+
+class EventProvider extends ServiceProvider {
+
+  * register () {
+    this.app.singleton('Adonis/Src/Event', function (app) {
+      const Event = require('../src/Event')
+      const Config = app.use('Adonis/Src/Config')
+      return new Event(Config)
+    })
+  }
+}
+
+module.exports = EventProvider

src/Event/index.js

@@ -0,0 +1,287 @@
+'use strict'
+
+/**
+ * adonis-framework
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+*/
+
+const EventEmitter2 = require('eventemitter2').EventEmitter2
+const Ioc = require('adonis-fold').Ioc
+const _ = require('lodash')
+const util = require('../../lib/util')
+const co = require('co')
+
+class Event {
+
+  constructor (Config) {
+    const options = Config.get('event')
+    this.namedListeners = {}
+    this.listenerLimit = null
+    this.emitter = new EventEmitter2(options)
+  }
+
+  /**
+   * here we resolve the handler from the IoC container
+   * or the actual callback if a closure was passed.
+   *
+   * @param  {String|Function}        handler
+   * @return {Object|Function}
+   *
+   * @private
+   */
+  _resolveHandler (handler) {
+    return typeof (handler) === 'string' ? Ioc.makeFunc(handler) : handler
+  }
+
+  /**
+   * here we bind the instance to the method, only
+   * if it exists.
+   *
+   * @param  {Object}      instance
+   * @param  {Function}      method
+   * @return {Function}
+   *
+   * @private
+   */
+  _bindInstance (instance, method) {
+    return function () {
+      instance.emitter = this
+      method.apply(instance, arguments)
+    }
+  }
+
+  /**
+   * here we wrap the generator method using co.wrap
+   * and make sure to pass the instance to the
+   * method.
+   *
+   * @param  {Object}       instance
+   * @param  {Function}       method
+   * @return {Function}
+   *
+   * @private
+   */
+  _wrapGenerator (instance, method) {
+    return co.wrap(function * () {
+      instance.emitter = this
+      yield method.apply(instance, arguments)
+    })
+  }
+
+  /**
+   * here we make the handler method with correct context and
+   * execution type. It makes it possible to use generator
+   * methods and other methods as event handler.
+   *
+   * @param  {Object|Function}     handler
+   * @return {Function}
+   *
+   * @private
+   */
+  _makeHandler (handler) {
+    let parentContext = {}
+    /**
+     * if handler is resolved out of IoC container, it will
+     * be an object with the parent context and the method.
+     */
+    if (typeof (handler) !== 'function' && handler.instance) {
+      parentContext = handler.instance
+      handler = handler.instance[handler.method]
+    }
+
+    /**
+     * if handler to the event is a generator, then we need to
+     * wrap it inside co with correct context
+     */
+    if (util.isGenerator(handler)) {
+      return this._wrapGenerator(parentContext, handler)
+    }
+
+    /**
+     * otherwise we bind the parentContext to the method
+     */
+    return this._bindInstance(parentContext, handler)
+  }
+
+  /**
+   * returns an array of listeners for a specific event
+   *
+   * @param  {String}     event
+   * @return {Array}
+   *
+   * @public
+   */
+  getListeners (event) {
+    return this.emitter.listeners(event)
+  }
+
+  /**
+   * it should tell whether there are any listeners
+   * for a given event or not.
+   *
+   * @param  {String}     event
+   * @return {Boolean}
+   *
+   * @public
+   */
+  hasListeners (event) {
+    return !!this.getListeners(event).length
+  }
+
+  /**
+   * returns the status for wildcard
+   *
+   *
+   * @return {Boolean}
+   *
+   * @public
+   */
+  wildcard () {
+    return this.emitter.wildcard
+  }
+
+  /**
+   * removes a named handler for a given event from the
+   * emitter
+   *
+   * @param  {String}       event
+   * @param  {String}       name
+   *
+   * @public
+   */
+  removeListener (event, name) {
+    const handler = this.namedListeners[name]
+    if (!handler) {
+      throw new Error(`There is no named event with ${name} name for ${event} event`)
+    }
+    this.emitter.removeListener(event, handler)
+  }
+
+  /**
+   * removes all listeners for a given or all events
+   *
+   * @param  {String}        [event]
+   *
+   * @public
+   */
+  removeListeners (event) {
+    event ? this.emitter.removeAllListeners(event) : this.emitter.removeAllListeners()
+  }
+
+  /**
+   * emits a given event and passes all the data
+   * to the handler
+   *
+   * @param {...Spread} data
+   *
+   * @public
+   */
+  emit () {
+    const args = _.toArray(arguments)
+    this.emitter.emit.apply(this.emitter, args)
+  }
+
+  /**
+   * @alias emit
+   */
+  fire () {
+    this.emit.apply(this, arguments)
+  }
+
+  /**
+   * binds an handler to any event
+   *
+   * @param  {Function|Sring} handler
+   *
+   * @public
+   */
+  any (handler) {
+    handler = this._resolveHandler(handler)
+    handler = this._makeHandler(handler)
+    this.emitter.onAny(handler)
+  }
+
+  /**
+   * defines a limit for a listener to be executed
+   *
+   * @param  {Number} limit
+   * @return {Object}
+   *
+   * @public
+   */
+  limit (limit) {
+    this.listenerLimit = limit
+    return this
+  }
+
+  /**
+   * adds a new event listen for a specific event
+   *
+   * @param  {String} event
+   * @param  {Function|String} handler
+   *
+   * @public
+   */
+  on (event, name, handler) {
+    if (!handler) {
+      handler = name
+      name = null
+    }
+    handler = this._resolveHandler(handler)
+    handler = this._makeHandler(handler)
+    if (name) {
+      this.namedListeners[name] = handler
+    }
+
+    /**
+     * if there is a limit define, go with the many
+     * method on the emitter
+     */
+    if (this.listenerLimit) {
+      this.emitter.many(event, this.listenerLimit, handler)
+      this.listenerLimit = null
+      return
+    }
+
+    /**
+     * otherwise register normally
+     */
+    this.emitter.on(event, handler)
+  }
+
+  /**
+   * @alias on
+   */
+  when () {
+    this.on.apply(this, arguments)
+  }
+
+  /**
+   * @alias on
+   */
+  listen () {
+    this.on.apply(this, arguments)
+  }
+
+  /**
+   * adds a new event listen for a specific event
+   * to be ran only for one time.
+   *
+   * @param  {String} event
+   * @param  {Function|String} handler
+   *
+   * @public
+   */
+  once (event, handler) {
+    handler = this._resolveHandler(handler)
+    handler = this._makeHandler(handler)
+    this.emitter.once(event, handler)
+  }
+
+}
+
+module.exports = Event