Initial commit.

Author: martinheidegger

EventProxy.js

@@ -0,0 +1,93 @@
+'use strict'
+var EventEmitter = require('events').EventEmitter
+var inherits = require('inherits')
+
+module.exports = EventProxy
+
+function EventProxy (proxied) {
+  this._listening = {}
+  this._ownEvents = {}
+  this._proxied = proxied
+}
+
+inherits(EventProxy, EventEmitter)
+
+Object.assign(EventProxy.prototype, {
+  _initEventProxy: function (eventName) {
+    if (this._ownEvents[eventName]) return
+
+    // Already listening to proxied event
+    if (this._listening[eventName] !== undefined) return
+
+    var self = this
+    var listener = function (payload) {
+      self.emit(eventName, payload)
+    }
+    this._listening[eventName] = listener
+    this._proxied.addListener(eventName, listener)
+  },
+  _exitEventProxy: function (eventName) {
+    if (this._ownEvents[eventName]) return
+
+    // Still listener for event given
+    if (this.listenerCount(eventName) > 0) return
+
+    var listener = this._listening[eventName]
+    // Called without ever being added
+    if (listener === undefined) return
+
+    delete this._listening[eventName]
+    this._proxied.removeListener(eventName, listener)
+  },
+  _exitAll: function () {
+    for (var eventName of this._listening) {
+      this._exitEventProxy(eventName)
+    }
+  },
+  addListener: function (eventName, listener) {
+    EventEmitter.prototype.addListener.call(this, eventName, listener)
+    this._initEventProxy(eventName)
+    return this
+  },
+  prependListener: function (eventName, listener) {
+    EventEmitter.prototype.prependListener.call(this, eventName, listener)
+    this._initEventProxy(eventName)
+    return this
+  },
+  removeListener: function (eventName, listener) {
+    EventEmitter.prototype.removeListener.call(this, eventName, listener)
+    this._exitEventProxy(eventName)
+    return this
+  },
+  removeAllListeners: function (eventName) {
+    EventEmitter.prototype.removeAllListeners.call(this, eventName)
+    if (arguments.length === 0) {
+      this._exitAll()
+    } else {
+      this._exitEventProxy(eventName)
+    }
+    return this
+  },
+  once: function (eventName, listener) {
+    var self = this
+    var wrapper = function (payload) {
+      listener(payload)
+      self.removeListener(eventName, wrapper)
+    }
+    return this.addListener(eventName, wrapper)
+  },
+  prependOnceListener: function (eventName, listener) {
+    var self = this
+    var wrapper = function (payload) {
+      listener(payload)
+      self.removeListener(eventName, wrapper)
+    }
+    return this.prependListener(eventName, wrapper)
+  },
+  on: function (eventName, listener) {
+    return this.addListener(eventName, listener)
+  },
+  off: function (eventName, listener) {
+    return this.removeListener(eventName, listener)
+  }
+})

EventProxy.test.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+const tape = require('tape')
+const events = require('events')
+const EventProxy = require('./EventProxy.js')
+
+tape('basic listening', function (t) {
+  var target = new events.EventEmitter()
+  var proxy = new EventProxy(target)
+  t.equals(proxy.listenerCount('hello'), 0, 'By default no listener is added')
+  target.addListener('hello', function () {})
+  t.equals(proxy.listenerCount('hello'), 0, 'Just because a listener is added to the target doesnt mean there is a listener on the source')
+  var addResult = proxy.addListener('holla', function (data) {
+    t.equals(data, 'mundo', 'target event is passed to the proxy')
+    t.end()
+  })
+  t.equals(addResult, proxy, 'Return type of ')
+  t.equals(target.listenerCount('holla'), 1, 'There should be a listener on the target, after adding one to the proxy')
+  target.emit('holla', 'mundo')
+})
+
+tape('once', function (t) {
+  var target = new events.EventEmitter()
+  var proxy = new EventProxy(target)
+  var count = 0
+  var addResult = proxy.once('hello', function (data) {
+    t.equals(count, 0, 'event called once.')
+    t.equals(data, 'world', 'data passed through')
+    count += 1
+  })
+  t.equals(addResult, proxy, 'Result of once should be the proxy instance')
+  t.equals(target.listenerCount('hello'), 1, 'Should have listener after once added')
+  target.emit('hello', 'world')
+  t.equals(target.listenerCount('hello'), 0, 'Should not have listener on target after once executed')
+  t.equals(proxy.listenerCount('hello'), 0, 'Should not have listener on proxy after once executed')
+  target.emit('hello', 'mundo')
+  t.end()
+})
+
+tape('prepend once', function (t) {
+  var target = new events.EventEmitter()
+  var proxy = new EventProxy(target)
+  var count = 0
+  target.addListener('hello', function () {
+    count += 1
+  })
+  proxy.addListener('hello', function () {
+    count += 2
+  })
+  var addResult = proxy.prependOnceListener('hello', function (data) {
+    t.equals(count, 1, 'event called once, before the listeners on proxy, after the listeners on target')
+    t.equals(data, 'world', 'data passed through')
+    count += 1
+  })
+  t.equals(addResult, proxy, 'Result of prepend once is proxy instance')
+  target.emit('hello', 'world')
+  target.emit('hello', 'mundo')
+  t.equals(count, 7)
+  t.end()
+})
+
+tape('remove all listeners', function (t) {
+  var target = new events.EventEmitter()
+  var proxy = new EventProxy(target)
+  var count = 0
+  target.addListener('hello', function () {
+    count += 1
+  })
+  proxy.addListener('hello', function () {
+    t.fail('Shouldnt be called because removed by removeAllListeners')
+  })
+  var removeResult = proxy.removeAllListeners('hello')
+  t.equals(removeResult, proxy, 'Result of removeAllListeners is proxy instance')
+  target.emit('hello', 'world')
+  t.equals(count, 1, 'target listener is still called')
+  t.end()
+})
+
+tape('own events', function (t) {
+  var target = new events.EventEmitter()
+  var proxy = new EventProxy(target)
+  proxy._ownEvents['hello'] = true
+  target.on('hello', function (data) {
+    t.equals(data, 'world', 'target called with world')
+  })
+  var onResult = proxy.on('hello', function (data) {
+    t.equals(data, 'mundo', 'proxy called with mundo, target not passed to proxy')
+  })
+  t.equals(onResult, proxy, 'result of on is proxy instance')
+  target.emit('hello', 'world')
+  proxy.emit('hello', 'mundo')
+  t.end()
+})

PauseWrapper.js

@@ -0,0 +1,104 @@
+
+'use strict'
+var EventProxy = require('./EventProxy.js')
+var EventEmitter = require('events').EventEmitter
+var inherits = require('inherits')
+
+module.exports = PauseWrapper
+
+function PauseWrapper (proxied) {
+  if (!(this instanceof PauseWrapper)) {
+    return new PauseWrapper(proxied)
+  }
+  EventProxy.call(this, proxied)
+  this._ownEvents['pause'] = true
+  this._ownEvents['paused'] = true
+  this._ownEvents['resume'] = true
+
+  this.pauseable = true
+  this._paused = false
+  this._closed = false
+}
+
+inherits(PauseWrapper, EventProxy)
+
+Object.assign(PauseWrapper.prototype, {
+  _onResume: function (handler) {
+    if (this._closed) return
+    if (this._paused || this.resuming) {
+      return this._pauseStack.push(handler)
+    }
+    handler.call(this)
+  },
+  _onResumeCb: function (cb, handler) {
+    var scope = this
+    this._onResume(function () {
+      handler.call(this, function (err, data) {
+        scope._onResume(function () {
+          if (!cb) return
+          cb.call(scope, err, data)
+        })
+      })
+    })
+  },
+  emit: function (eventName, payload) {
+    if (eventName === 'close' || eventName === 'destroy') {
+      this._closed = true
+      return EventEmitter.prototype.emit.call(this, eventName, payload)
+    }
+    if (this._closed) {
+      return
+    }
+    if (eventName === 'pause' || eventName === 'resume' || eventName === 'paused') {
+      return EventEmitter.prototype.emit.call(this, eventName, payload)
+    }
+    var scope = this
+    this._onResume(function () { EventEmitter.prototype.emit.call(scope, eventName, payload) })
+  },
+  setPaused: function (paused) {
+    if (paused === this._paused) return false
+    if (this._resuming) {
+      var scope = this
+      this._pauseStack.push(function () { scope.setPaused(paused) })
+      return false
+    }
+    this._paused = paused
+    if (paused) {
+      this._pauseStack = []
+    } else {
+      while (this._pauseStack) {
+        var pauseStack = this._pauseStack
+        delete this._pauseStack
+        while (pauseStack.length > 0) {
+          var handler = pauseStack.shift()
+          handler()
+        }
+      }
+    }
+    this.emit('paused', paused)
+    if (paused) {
+      this.emit('pause')
+    } else {
+      this.emit('resume')
+    }
+    return true
+  },
+  pause: function () {
+    return this.setPaused(true)
+  },
+  resume: function () {
+    return this.setPaused(false)
+  }
+})
+
+Object.defineProperties(PauseWrapper.prototype, {
+  paused: {
+    get: function () {
+      return this._paused
+    },
+    set: function (paused) {
+      this.setPaused(paused)
+      return this._paused
+    }
+  }
+})