game_dig 0.0.1 → 0.2.0

data/lib/game_dig/node/node_modules/emitter-component/test/emitter.js

@@ -0,0 +1,195 @@
+
+var Emitter = require('..');
+
+function Custom() {
+  Emitter.call(this)
+}
+
+Custom.prototype.__proto__ = Emitter.prototype;
+
+describe('Custom', function(){
+  describe('with Emitter.call(this)', function(){
+    it('should work', function(done){
+      var emitter = new Custom;
+      emitter.on('foo', done);
+      emitter.emit('foo');
+    })
+  })
+})
+
+describe('Emitter', function(){
+  describe('.on(event, fn)', function(){
+    it('should add listeners', function(){
+      var emitter = new Emitter;
+      var calls = [];
+
+      emitter.on('foo', function(val){
+        calls.push('one', val);
+      });
+
+      emitter.on('foo', function(val){
+        calls.push('two', val);
+      });
+
+      emitter.emit('foo', 1);
+      emitter.emit('bar', 1);
+      emitter.emit('foo', 2);
+
+      calls.should.eql([ 'one', 1, 'two', 1, 'one', 2, 'two', 2 ]);
+    })
+  })
+
+  describe('.once(event, fn)', function(){
+    it('should add a single-shot listener', function(){
+      var emitter = new Emitter;
+      var calls = [];
+
+      emitter.once('foo', function(val){
+        calls.push('one', val);
+      });
+
+      emitter.emit('foo', 1);
+      emitter.emit('foo', 2);
+      emitter.emit('foo', 3);
+      emitter.emit('bar', 1);
+
+      calls.should.eql([ 'one', 1 ]);
+    })
+  })
+
+  describe('.off(event, fn)', function(){
+    it('should remove a listener', function(){
+      var emitter = new Emitter;
+      var calls = [];
+
+      function one() { calls.push('one'); }
+      function two() { calls.push('two'); }
+
+      emitter.on('foo', one);
+      emitter.on('foo', two);
+      emitter.off('foo', two);
+
+      emitter.emit('foo');
+
+      calls.should.eql([ 'one' ]);
+    })
+
+    it('should work with .once()', function(){
+      var emitter = new Emitter;
+      var calls = [];
+
+      function one() { calls.push('one'); }
+
+      emitter.once('foo', one);
+      emitter.once('fee', one);
+      emitter.off('foo', one);
+
+      emitter.emit('foo');
+
+      calls.should.eql([]);
+    })
+
+    it('should work when called from an event', function(){
+      var emitter = new Emitter
+        , called
+      function b () {
+        called = true;
+      }
+      emitter.on('tobi', function () {
+        emitter.off('tobi', b);
+      });
+      emitter.on('tobi', b);
+      emitter.emit('tobi');
+      called.should.be.true;
+      called = false;
+      emitter.emit('tobi');
+      called.should.be.false;
+    });
+  })
+
+  describe('.off(event)', function(){
+    it('should remove all listeners for an event', function(){
+      var emitter = new Emitter;
+      var calls = [];
+
+      function one() { calls.push('one'); }
+      function two() { calls.push('two'); }
+
+      emitter.on('foo', one);
+      emitter.on('foo', two);
+      emitter.off('foo');
+
+      emitter.emit('foo');
+      emitter.emit('foo');
+
+      calls.should.eql([]);
+    })
+  })
+
+  describe('.off()', function(){
+    it('should remove all listeners', function(){
+      var emitter = new Emitter;
+      var calls = [];
+
+      function one() { calls.push('one'); }
+      function two() { calls.push('two'); }
+
+      emitter.on('foo', one);
+      emitter.on('bar', two);
+
+      emitter.emit('foo');
+      emitter.emit('bar');
+
+      emitter.off();
+
+      emitter.emit('foo');
+      emitter.emit('bar');
+
+      calls.should.eql(['one', 'two']);
+    })
+  })
+
+  describe('.listeners(event)', function(){
+    describe('when handlers are present', function(){
+      it('should return an array of callbacks', function(){
+        var emitter = new Emitter;
+        function foo(){}
+        emitter.on('foo', foo);
+        emitter.listeners('foo').should.eql([foo]);
+      })
+    })
+
+    describe('when no handlers are present', function(){
+      it('should return an empty array', function(){
+        var emitter = new Emitter;
+        emitter.listeners('foo').should.eql([]);
+      })
+    })
+  })
+
+  describe('.hasListeners(event)', function(){
+    describe('when handlers are present', function(){
+      it('should return true', function(){
+        var emitter = new Emitter;
+        emitter.on('foo', function(){});
+        emitter.hasListeners('foo').should.be.true;
+      })
+    })
+
+    describe('when no handlers are present', function(){
+      it('should return false', function(){
+        var emitter = new Emitter;
+        emitter.hasListeners('foo').should.be.false;
+      })
+    })
+  })
+})
+
+describe('Emitter(obj)', function(){
+  it('should mixin', function(done){
+    var proto = {};
+    Emitter(proto);
+    proto.on('something', done);
+    proto.emit('something');
+  })
+})

data/lib/game_dig/node/node_modules/event-to-promise/LICENSE

@@ -0,0 +1,14 @@
+Copyright (c) 2014, Julien Fontanet <julien.fontanet@isonoe.net>.
+
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

data/lib/game_dig/node/node_modules/event-to-promise/README.md

@@ -0,0 +1,180 @@
+# event-to-promise
+
+[![Build Status](https://img.shields.io/travis/julien-f/event-to-promise/master.svg)](http://travis-ci.org/julien-f/event-to-promise)
+[![Dependency Status](https://david-dm.org/julien-f/event-to-promise/status.svg?theme=shields.io)](https://david-dm.org/julien-f/event-to-promise)
+[![devDependency Status](https://david-dm.org/julien-f/event-to-promise/dev-status.svg?theme=shields.io)](https://david-dm.org/julien-f/event-to-promise#info=devDependencies)
+
+> Create a promise waiting for an event
+
+
+## Install
+
+Download [manually](https://github.com/julien-f/event-to-promise/releases) or with package-manager.
+
+#### [npm](https://npmjs.org/package/event-to-promise)
+
+```
+npm install --save event-to-promise
+```
+
+This library requires promises support, for Node versions prior to 0.12 [see
+this page](https://github.com/julien-f/js-promise-toolbox#usage) to
+enable them.
+
+## Example
+
+```javascript
+var eventToPromise = require('event-to-promise')
+
+function createServer (port) {
+  var server = require('http').createServer()
+  server.listen(port)
+
+  // The server will be returned once it has started listening.
+  //
+  // If an error happened, it will be forwarded instead.
+  return eventToPromise(server, 'listening').then(function () {
+    return server
+  })
+}
+
+// Using plain promise.
+createServer(80).then(function (server) {
+  console.log('Server listening on http://localhost:80/')
+}).catch(function (error) {
+  console.error('Server could not start:', error)
+})
+```
+
+Event better using [ES2016 asynchronous functions](https://github.com/tc39/ecmascript-asyncawait):
+
+```js
+import eventToPromise from 'event-to-promise'
+
+async function createServer (port) {
+  var server = require('http').createServer()
+  server.listen(port)
+
+  await eventToPromise(server, 'listening')
+
+  return server
+}
+
+async function main () {
+  try {
+    const server = await createServer(80);
+    console.log('Server listening on http://localhost:80/');
+  } catch (error) {
+    console.error('Server could not start:', error);
+  }
+}
+
+main()
+```
+
+## API
+
+### eventToPromise(emitter, event, [options]) => Promise
+
+> Wait for one event. The first parameter of the emitted event is used
+> to resolve/reject the promise.
+
+The returned promise has a `cancel()` method which can be used to
+remove the event listeners. Note that the promise will never settled
+if canceled.
+
+```js
+const promise = eventToPromise(emitter, 'foo')
+promise.cancel()
+```
+
+#### emitter
+
+*Required*
+Type: `Object`
+
+The event emitter you want to watch an event on.
+
+#### event
+
+*Required*
+Type: `string`
+
+The name of the event you want to watch.
+
+#### options
+
+##### array
+
+Type: `boolean`
+Default: `false`
+
+If true, all parameters of the emitted events are put in an array which is used to resolve/reject the promise.
+
+##### error
+
+Type: `string`
+Default: `"error"`
+
+The name of the event which rejects the promise.
+
+##### ignoreErrors
+
+Type: `boolean`
+Default: `false`
+
+Whether the error event should be ignored and not reject the promise.
+
+### eventToPromise.multi(emitter, successEvents, errorEvents) => Promise
+
+> Wait for one of multiple events. The array of all the parameters of
+> the emitted event is used to resolve/reject the promise.
+>
+> The array also has an `event` property indicating which event has
+> been emitted.
+
+The returned promise has a `cancel()` method which can be used to
+remove the event listeners. Note that the promise will never settled
+if canceled.
+
+```js
+const promise = eventToPromise(emitter, 'foo')
+promise.cancel()
+```
+
+#### emitter
+
+*Required*
+Type: `Object`
+
+The event emitter you want to watch an event on.
+
+#### successEvents
+
+*Required*
+Type: `Array<string>`
+
+The names of the events which resolve the promise.
+
+#### errorEvents
+
+Type: `Array<string>`
+Default: `[ 'error' ]`
+
+The names of the events which reject the promise.
+
+
+## Contributing
+
+Contributions are *very* welcome, either on the documentation or on
+the code.
+
+You may:
+
+- report any [issue](https://github.com/julien-f/event-to-promise/issues)
+  you've encountered;
+- fork and create a pull request.
+
+## License
+
+ISC © [Julien Fontanet](http://julien.isonoe.net)

data/lib/game_dig/node/node_modules/event-to-promise/index.js

@@ -0,0 +1,106 @@
+'use strict'
+
+// ===================================================================
+
+function noop () {}
+
+function makeEventAdder (emitter, arrayArg) {
+  var addListener =
+    emitter.addEventListener ||
+    emitter.addListener ||
+    emitter.on
+
+  if (!addListener) {
+    throw new Error('cannot register an event listener')
+  }
+
+  var removeListener =
+    emitter.removeEventListener ||
+    emitter.removeListener ||
+    emitter.off
+
+  var eventsAndListeners = []
+
+  var cleanUp = removeListener
+    ? function () {
+      for (var i = 0, n = eventsAndListeners.length; i < n; i += 2) {
+        removeListener.call(emitter, eventsAndListeners[i], eventsAndListeners[i + 1])
+      }
+    }
+    : noop
+
+  function addEvent (event, cb) {
+    function listener () {
+      cleanUp()
+
+      var arg
+      var n = arguments.length
+      if (arrayArg) {
+        arg = new Array(n)
+        for (var i = 0; i < n; ++i) {
+          arg[i] = arguments[i]
+        }
+        arg.event = event
+      } else {
+        arg = n > 0 ? arguments[0] : undefined
+      }
+
+      cb(arg)
+    }
+
+    eventsAndListeners.push(event, listener)
+    addListener.call(emitter, event, listener)
+  }
+  addEvent.cleanUp = cleanUp
+
+  return addEvent
+}
+
+// ===================================================================
+
+function eventToPromise (emitter, event, opts) {
+  var cancel
+  var promise = new Promise(function (resolve, reject) {
+    var addEvent = makeEventAdder(emitter, opts && opts.array)
+    cancel = function () {
+      cancel = noop
+      addEvent.cleanUp()
+    }
+
+    addEvent(event, resolve)
+
+    if (!opts || !opts.ignoreErrors) {
+      addEvent(opts && opts.error || 'error', reject)
+    }
+  })
+  promise.cancel = function () { return cancel() }
+
+  return promise
+}
+
+var defaultErrorEvents = [ 'error' ]
+eventToPromise.multi = function eventsToPromise (emitter, successEvents, errorEvents) {
+  errorEvents || (errorEvents = defaultErrorEvents)
+
+  var cancel
+  var promise = new Promise(function (resolve, reject) {
+    var addEvent = makeEventAdder(emitter, true)
+    cancel = function () {
+      cancel = noop
+      addEvent.cleanUp()
+    }
+
+    var i, n
+    for (i = 0, n = successEvents.length; i < n; ++i) {
+      addEvent(successEvents[i], resolve)
+    }
+    for (i = 0, n = errorEvents.length; i < n; ++i) {
+      addEvent(errorEvents[i], reject)
+    }
+  })
+  promise.cancel = function () { return cancel() }
+
+  return promise
+}
+
+module.exports = eventToPromise

data/lib/game_dig/node/node_modules/event-to-promise/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "event-to-promise",
+  "version": "0.7.0",
+  "license": "MIT",
+  "description": "Create a promise waiting for an event",
+  "keywords": [
+    "event",
+    "promise"
+  ],
+  "homepage": "https://github.com/julien-f/event-to-promise",
+  "bugs": "https://github.com/julien-f/event-to-promise/issues",
+  "author": {
+    "name": "Julien Fontanet",
+    "email": "julien.fontanet@isonoe.net",
+    "url": "http://julien.isonoe.net"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/julien-f/event-to-promise"
+  },
+  "devDependencies": {
+    "mocha": "^2.2.5",
+    "must": "^0.13.1",
+    "native-promise-only": "^0.8.1",
+    "standard": "^6.0.4"
+  },
+  "scripts": {
+    "lint": "standard",
+    "posttest": "npm run lint",
+    "test": "mocha index.spec.js"
+  },
+  "files": [
+    "index.js"
+  ]
+}