game_dig 0.1.0 → 0.2.0

data/lib/game_dig/node/node_modules/barse/README.md

@@ -0,0 +1,138 @@
+
+# barse
+
+Binary parser with a fluent API.
+
+[![build status](https://secure.travis-ci.org/juliangruber/barse.png)](http://travis-ci.org/juliangruber/barse)
+
+[![testling badge](https://ci.testling.com/juliangruber/barse.png)](https://ci.testling.com/juliangruber/barse)
+
+## Usage
+
+```js
+var parse = require('..');
+
+var parser = parse()
+  .readUInt8('string length')
+  .string('string', 'string length')
+  .readUInt8('field count')
+  .loop('fields', 2, function (loop) {
+    loop.readUInt8('some');
+    loop.readUInt8('numbers');
+  })
+
+parser.on('data', console.log);
+/*
+{
+  "string length" : 3,
+  "string" : "foo",
+  "field count" : 2,
+  "fields" : [
+    { "some" : 13, "numbers" : 37 },
+    { "some" : 73, "numbers" : 31 }
+  ]
+}
+*/
+
+var buf = new Buffer(9);
+buf.writeUInt8(3, 0); // string length
+buf.write('foo', 1); // string
+buf.writeUInt8(2, 4); // field count
+buf.writeUInt8(13, 5); // fields[0].some
+buf.writeUInt8(37, 6); // fields[0].numbers
+buf.writeUInt8(73, 7); // fields[1].some
+buf.writeUInt8(31, 8); // fields[1].numbers
+
+parser.write(buf);
+```
+
+## API
+
+### parse()
+
+Create a new streaming parser.
+
+### parse#string(name, length[, encoding])
+### parse#buffer(name, length)
+### parse#read(U)Int{8,16,32}{BE,LE}(name)
+### parse#read{Float,Double}{BE,LE}(name)
+
+Parse the given type with optional length and store in the results object under
+`name`.
+
+`length` can also be the name of a previously read field, e.g.:
+
+```js
+parse()
+  .readUInt8('length')
+  .string('content', 'length');
+```
+
+### parse#next(name, length, fn)
+
+Consume a chunk of binary data with the given `length`.
+
+`fn` is called with the current `chunk` and `offset` and is expected to synchronously return the parsed Object/String/whatever, which then will be emitted under `name` in the results object.
+In addition, `fn` is bound to the object containing the parsed data of the current chunk.
+
+The example above written using `next`:
+
+```js
+parse()
+  .next('foo', 3, function (chunk, offset) {
+    return chunk.toString('utf8', offset, offset + 3);
+  })
+  .next('bar', 3, function (chunk, offset) {
+    return chunk.toString('utf8', offset, offset + 3);
+  })
+```
+
+### parse#loop(name, length, fn)
+
+Read `length` buffers and store under `name`.
+
+```js
+var parser = parse()
+  .readUInt8('count')
+  .loop('strings', 'count', function (loop) {
+    loop.string('value', 3);
+  });
+
+parser.on('data', console.log);
+// => { strings : [{ value : 'foo' }, { value : 'bar' }]}
+
+var count = new Buffer(1); count.writeUInt8(1, 0); parser.write(count);
+parser.write(new Buffer('foobar'));
+```
+
+## Installation
+
+With [npm](http://npmjs.org) do
+
+```bash
+$ npm install barse
+```
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/game_dig/node/node_modules/barse/example/complete.js

@@ -0,0 +1,34 @@
+var parse = require('..');
+
+var parser = parse()
+  .readUInt8('string length')
+  .string('string', 'string length')
+  .readUInt8('field count')
+  .loop('fields', 'field count', function (loop) {
+    loop.readUInt8('some');
+    loop.readUInt8('numbers');
+  })
+
+parser.on('data', console.log);
+/*
+{
+  "string length" : 3,
+  "string" : "foo",
+  "field count" : 2,
+  "fields" : [
+    { "some" : 13, "numbers" : 37 },
+    { "some" : 73, "numbers" : 13 }
+  ]
+}
+*/
+
+var buf = new Buffer(9);
+buf.writeUInt8(3, 0); // string length
+buf.write('foo', 1); // string
+buf.writeUInt8(2, 4); // field count
+buf.writeUInt8(13, 5); // fields[0].some
+buf.writeUInt8(37, 6); // fields[0].numbers
+buf.writeUInt8(73, 7); // fields[1].some
+buf.writeUInt8(31, 8); // fields[1].numbers
+
+parser.write(buf);

data/lib/game_dig/node/node_modules/barse/example/next.js

@@ -0,0 +1,21 @@
+var parse = require('..');
+
+var parser = parse()
+  .next('a', 1, function (chunk, offset) {
+    return chunk.readUInt8(offset);
+  })
+  .next('b', 4, function (chunk, offset) {
+    return chunk.readUInt32LE(offset);
+  })
+
+parser.on('data', console.log);
+
+var leet = new Buffer(5);
+leet.writeUInt8(13, 0);
+leet.writeUInt32LE(37, 1);
+parser.write(leet);
+
+var teel = new Buffer(5);
+teel.writeUInt8(73, 0);
+teel.writeUInt32LE(31, 1);
+parser.write(teel);

data/lib/game_dig/node/node_modules/barse/index.js

@@ -0,0 +1,282 @@
+
+/**
+ * Module dependencies.
+ */
+
+var Buffer = require('buffer').Buffer;
+var inherits = require('util').inherits;
+var Transform = require('readable-stream').Transform;
+
+/**
+ * Expose `Parser`.
+ */
+
+module.exports = Parser;
+
+/**
+ * Create a new `Parser`.
+ *
+ * @return {Parser}
+ * @api public
+ */
+
+function Parser () {
+  if (!(this instanceof Parser)) return new Parser();
+
+  Transform.call(this, {
+    objectMode : true
+  });
+
+  this.steps = [];
+  this.idx = 0;
+  this.res = {};
+  this.offset = 0;
+  this.buf = null;
+}
+
+inherits(Parser, Transform);
+
+/**
+ * Transform callback.
+ *
+ * @param {Buffer} chunk
+ * @param {String} encoding
+ * @param {Function} done
+ * @api private
+ */
+
+Parser.prototype._transform = function (chunk, encoding, done) {
+  if (this.buf) {
+    chunk = Buffer.concat([this.buf, chunk]);
+    this.buf = null;
+  }
+
+  while (true) {
+    var broken = false;
+    for (var i = 0; i < this.steps.length; i++) {
+      var step = this.steps[i];
+      if (this.idx == i) {
+        var stepLength;
+        
+        if (typeof step.length === 'number') {
+          stepLength = step.length;
+        } else if (typeof step.length === 'string') {
+          stepLength = this.res[step.length];
+        } else if (typeof step.chunkLength == 'number') {
+          if (typeof step.iterations === 'number') {
+            stepLength = step.iterations * step.chunkLength;
+          } else if (typeof step.iterations === 'string') {
+            stepLength = this.res[step.iterations] * step.chunkLength;
+          }
+        }
+
+        if (chunk.length < stepLength + this.offset) {
+          broken = true;
+          break;
+        }
+
+        this.res[step.name] = step.fn.apply(this.res, [chunk, this.offset]);
+        this.offset += stepLength;
+        this.idx++;
+      }
+
+      if (i === this.steps.length - 1) {
+        this.push(this.res);
+        this.res = {};
+        this.idx = 0;
+      }
+    }
+    if (broken) break;
+  }
+
+  if (chunk.length != this.offset) {
+    var dif = Math.abs(chunk.length - this.offset);
+    this.buf = new Buffer(dif);
+    chunk.copy(this.buf, 0, chunk.length - dif);
+  }
+
+  this.offset = 0;
+
+  done();
+};
+
+/**
+ * Register a parser function.
+ *
+ * @param {String} name
+ * @param {Number|String} length
+ * @param {Function} fn
+ * @return {Parser}
+ * @api public
+ */
+
+Parser.prototype.next = function (name, length, fn) {
+  this.steps.push({ name : name, length : length, fn : fn });
+  return this;
+};
+
+/**
+ * Loop `length` times and save in `name` what `fn` registers.
+ *
+ * @param {String} name
+ * @param {Number|String} length
+ * @param {Function} fn
+ * @return {Parser}
+ * @api public
+ */
+
+Parser.prototype.loop = function (name, length, fn) {
+  // Get static chunk length
+  var parse = Parser();
+  fn(parse);
+  var chunkLength = parse.chunkLength();
+  
+  this.steps.push({
+    name : name,
+    iterations : length,
+    chunkLength : chunkLength,
+    fn : function (chunk, offset) {
+      // let `fn` add parsing rules
+      var parse = Parser();
+      fn(parse);
+
+      // parse.on('data') fires synchronously
+      var res = [];
+      parse.on('data', function (data) {
+        res.push(data);
+      });
+
+      // iterations * chunkLength
+      if (typeof length === 'string') length = this[length];
+      length = length * parse.chunkLength();
+
+      // write to the parser
+      var buf = new Buffer(length);
+      chunk.copy(buf, 0, offset, offset + length);
+      parse.write(buf);
+
+      return res;
+    }
+  });
+  return this;
+}
+
+/**
+ * Get the byte length of all steps together.
+ *
+ * @return {Number}
+ * @api private
+ */
+
+Parser.prototype.chunkLength = function () {
+  return this.steps.reduce(function (acc, step) {
+    return acc + step.length;
+  }, 0);
+};
+
+/**
+ * API sugar.
+ */
+
+Parser.prototype.string = function (name, length, encoding) {
+  if (!encoding) encoding = 'utf8';
+  var self = this;
+  return self.next(name, length, function (chunk, offset) {
+    var len = (typeof length === 'string') ? this[length] : length;
+    return chunk.toString(encoding, offset, offset + len);
+  });
+};
+
+Parser.prototype.buffer = function (name, length) {
+  var self = this;
+  return self.next(name, length, function (chunk, offset) {
+    var len = (typeof length === 'string') ? this[length] : length;
+    var buf = new Buffer(len);
+    chunk.copy(buf, 0, offset, offset + len);
+    return buf;
+  });
+};
+
+Parser.prototype.readUInt8 = function (name) {
+  return this.next(name, 1, function (chunk, offset) {
+    return chunk.readUInt8(offset);
+  });
+};
+
+Parser.prototype.readUInt16LE = function (name) {
+  return this.next(name, 2, function (chunk, offset) {
+    return chunk.readUInt16LE(offset);
+  });
+};
+
+Parser.prototype.readUInt16BE = function (name) {
+  return this.next(name, 2, function (chunk, offset) {
+    return chunk.readUInt16BE(offset);
+  });
+};
+
+Parser.prototype.readUInt32LE = function (name) {
+  return this.next(name, 4, function (chunk, offset) {
+    return chunk.readUInt32LE(offset);
+  });
+};
+
+Parser.prototype.readUInt32BE = function (name) {
+  return this.next(name, 4, function (chunk, offset) {
+    return chunk.readUInt32BE(offset);
+  });
+};
+
+Parser.prototype.readInt8 = function (name) {
+  return this.next(name, 1, function (chunk, offset) {
+    return chunk.readInt8(offset);
+  });
+};
+
+Parser.prototype.readInt16LE = function (name) {
+  return this.next(name, 2, function (chunk, offset) {
+    return chunk.readInt16LE(offset);
+  });
+};
+
+Parser.prototype.readInt16BE = function (name) {
+  return this.next(name, 2, function (chunk, offset) {
+    return chunk.readInt16BE(offset);
+  });
+};
+
+Parser.prototype.readInt32LE = function (name) {
+  return this.next(name, 4, function (chunk, offset) {
+    return chunk.readInt32LE(offset);
+  });
+};
+
+Parser.prototype.readInt32BE = function (name) {
+  return this.next(name, 4, function (chunk, offset) {
+    return chunk.readInt32BE(offset);
+  });
+};
+
+Parser.prototype.readFloatLE = function (name) {
+  return this.next(name, 4, function (chunk, offset) {
+    return chunk.readFloatLE(offset);
+  });
+};
+
+Parser.prototype.readFloatBE = function (name) {
+  return this.next(name, 4, function (chunk, offset) {
+    return chunk.readFloatBE(offset);
+  });
+};
+
+Parser.prototype.readDoubleLE = function (name) {
+  return this.next(name, 8, function (chunk, offset) {
+    return chunk.readDoubleLE(offset);
+  });
+};
+
+Parser.prototype.readDoubleBE = function (name) {
+  return this.next(name, 8, function (chunk, offset) {
+    return chunk.readDoubleBE(offset);
+  });
+};

data/lib/game_dig/node/node_modules/barse/node_modules/readable-stream/.npmignore

@@ -0,0 +1,5 @@
+build/
+test/
+examples/
+fs.js
+zlib.js

data/lib/game_dig/node/node_modules/barse/node_modules/readable-stream/LICENSE

@@ -0,0 +1,18 @@
+Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

data/lib/game_dig/node/node_modules/barse/node_modules/readable-stream/README.md

@@ -0,0 +1,15 @@
+# readable-stream
+
+***Node-core streams for userland***
+
+[![NPM](https://nodei.co/npm/readable-stream.png?downloads=true&downloadRank=true)](https://nodei.co/npm/readable-stream/)
+[![NPM](https://nodei.co/npm-dl/readable-stream.png?&months=6&height=3)](https://nodei.co/npm/readable-stream/)
+
+This package is a mirror of the Streams2 and Streams3 implementations in Node-core.
+
+If you want to guarantee a stable streams base, regardless of what version of Node you, or the users of your libraries are using, use **readable-stream** *only* and avoid the *"stream"* module in Node-core.
+
+**readable-stream** comes in two major versions, v1.0.x and v1.1.x. The former tracks the Streams2 implementation in Node 0.10, including bug-fixes and minor improvements as they are added. The latter tracks Streams3 as it develops in Node 0.11; we will likely see a v1.2.x branch for Node 0.12.
+
+**readable-stream** uses proper patch-level versioning so if you pin to `"~1.0.0"` you’ll get the latest Node 0.10 Streams2 implementation, including any fixes and minor non-breaking improvements. The patch-level versions of 1.0.x and 1.1.x should mirror the patch-level versions of Node-core releases. You should prefer the **1.0.x** releases for now and when you’re ready to start using Streams3, pin to `"~1.1.0"`
+

data/lib/game_dig/node/node_modules/barse/node_modules/readable-stream/duplex.js

@@ -0,0 +1 @@
+module.exports = require("./lib/_stream_duplex.js")

data/lib/game_dig/node/node_modules/barse/node_modules/readable-stream/lib/_stream_duplex.js

@@ -0,0 +1,89 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+module.exports = Duplex;
+
+/*<replacement>*/
+var objectKeys = Object.keys || function (obj) {
+  var keys = [];
+  for (var key in obj) keys.push(key);
+  return keys;
+}
+/*</replacement>*/
+
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var Readable = require('./_stream_readable');
+var Writable = require('./_stream_writable');
+
+util.inherits(Duplex, Readable);
+
+forEach(objectKeys(Writable.prototype), function(method) {
+  if (!Duplex.prototype[method])
+    Duplex.prototype[method] = Writable.prototype[method];
+});
+
+function Duplex(options) {
+  if (!(this instanceof Duplex))
+    return new Duplex(options);
+
+  Readable.call(this, options);
+  Writable.call(this, options);
+
+  if (options && options.readable === false)
+    this.readable = false;
+
+  if (options && options.writable === false)
+    this.writable = false;
+
+  this.allowHalfOpen = true;
+  if (options && options.allowHalfOpen === false)
+    this.allowHalfOpen = false;
+
+  this.once('end', onend);
+}
+
+// the no-half-open enforcer
+function onend() {
+  // if we allow half-open state, or if the writable side ended,
+  // then we're ok.
+  if (this.allowHalfOpen || this._writableState.ended)
+    return;
+
+  // no more data can be written.
+  // But allow more writes to happen in this tick.
+  process.nextTick(this.end.bind(this));
+}
+
+function forEach (xs, f) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    f(xs[i], i);
+  }
+}

data/lib/game_dig/node/node_modules/barse/node_modules/readable-stream/lib/_stream_passthrough.js

@@ -0,0 +1,46 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+module.exports = PassThrough;
+
+var Transform = require('./_stream_transform');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+  if (!(this instanceof PassThrough))
+    return new PassThrough(options);
+
+  Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function(chunk, encoding, cb) {
+  cb(null, chunk);
+};