msgpack-lite 0.1.17 → 0.1.26

package/lib/encode-buffer.js

@@ -2,67 +2,26 @@
 
 exports.EncodeBuffer = EncodeBuffer;
 
-var preset = require("./ext-preset").preset;
-var MIN_BUFFER_SIZE = 2048;
-var MAX_BUFFER_SIZE = 65536;
-var DEFAULT_OPTIONS = {};
+var preset = require("./write-core").preset;
 
-function EncodeBuffer(options) {
-  if (!(this instanceof EncodeBuffer)) return new EncodeBuffer(options);
-  this.options = options || DEFAULT_OPTIONS;
-  this.codec = this.options.codec || preset;
-}
+var FlexEncoder = require("./flex-buffer").FlexEncoder;
 
-EncodeBuffer.prototype.push = function(chunk) {
-  var buffers = this.buffers || (this.buffers = []);
-  buffers.push(chunk);
-};
+FlexEncoder.mixin(EncodeBuffer.prototype);
 
-EncodeBuffer.prototype.read = function() {
-  this.flush();
-  var buffers = this.buffers;
-  if (!buffers) return;
-  var chunk = buffers.length > 1 ? Buffer.concat(buffers) : buffers[0];
-  buffers.length = 0;
-  return chunk;
-};
+function EncodeBuffer(options) {
+  if (!(this instanceof EncodeBuffer)) return new EncodeBuffer(options);
 
-EncodeBuffer.prototype.flush = function() {
-  if (this.start < this.offset) {
-    this.push(this.buffer.slice(this.start, this.offset));
-    this.start = this.offset;
+  if (options) {
+    this.options = options;
+    if (options.codec) {
+      var codec = this.codec = options.codec;
+      if (codec.bufferish) this.bufferish = codec.bufferish;
+    }
   }
-};
-
-EncodeBuffer.prototype.reserve = function(length) {
-  if (!this.buffer) return this.alloc(length);
-
-  var size = this.buffer.length;
-
-  // is it long enough?
-  if (this.offset + length < size) return;
-
-  // flush current buffer
-  if (this.offset) this.flush();
-
-  // resize it to 2x current length
-  this.alloc(Math.max(length, Math.min(size * 2, MAX_BUFFER_SIZE)));
-};
+}
 
-EncodeBuffer.prototype.alloc = function(length) {
-  // allocate new buffer
-  this.buffer = new Buffer(length > MIN_BUFFER_SIZE ? length : MIN_BUFFER_SIZE);
-  this.start = 0;
-  this.offset = 0;
-};
+EncodeBuffer.prototype.codec = preset;
 
-EncodeBuffer.prototype.send = function(buffer) {
-  var end = this.offset + buffer.length;
-  if (this.buffer && end < this.buffer.length) {
-    buffer.copy(this.buffer, this.offset);
-    this.offset = end;
-  } else {
-    this.flush();
-    this.push(buffer);
-  }
+EncodeBuffer.prototype.write = function(input) {
+  this.codec.encode(this, input);
 };

package/lib/encode-stream.js

@@ -5,7 +5,6 @@ exports.createEncodeStream = EncodeStream;
 var util = require("util");
 var Transform = require("stream").Transform;
 var EncodeBuffer = require("./encode-buffer").EncodeBuffer;
-var encode = require("./write-core").encode;
 
 util.inherits(EncodeStream, Transform);
 
@@ -28,7 +27,7 @@ function EncodeStream(options) {
 }
 
 EncodeStream.prototype._transform = function(chunk, encoding, callback) {
-  encode(this.encoder, chunk);
+  this.encoder.write(chunk);
   if (callback) callback();
 };
 

package/lib/encode.js

@@ -2,11 +2,10 @@
 
 exports.encode = encode;
 
-var encode = require("./write-core").encode;
 var EncodeBuffer = require("./encode-buffer").EncodeBuffer;
 
 function encode(input, options) {
   var encoder = new EncodeBuffer(options);
-  encode(encoder, input);
+  encoder.write(input);
   return encoder.read();
 }

package/lib/encoder.js

@@ -3,7 +3,6 @@
 exports.Encoder = Encoder;
 
 var EventLite = require("event-lite");
-var encode = require("./write-core").encode;
 var EncodeBuffer = require("./encode-buffer").EncodeBuffer;
 
 function Encoder(options) {
@@ -16,7 +15,7 @@ Encoder.prototype = new EncodeBuffer();
 EventLite.mixin(Encoder.prototype);
 
 Encoder.prototype.encode = function(chunk) {
-  encode(this, chunk);
+  this.write(chunk);
   this.emit("data", this.read());
 };
 

package/lib/ext-buffer.js

@@ -2,8 +2,10 @@
 
 exports.ExtBuffer = ExtBuffer;
 
+var Bufferish = require("./bufferish");
+
 function ExtBuffer(buffer, type) {
   if (!(this instanceof ExtBuffer)) return new ExtBuffer(buffer, type);
-  this.buffer = buffer;
+  this.buffer = Bufferish.from(buffer);
   this.type = type;
 }

package/lib/ext-packer.js

@@ -0,0 +1,78 @@
+// ext-packer.js
+
+exports.setExtPackers = setExtPackers;
+
+var Bufferish = require("./bufferish");
+var Buffer = Bufferish.global;
+var packTypedArray = Bufferish.Uint8Array.from;
+var _encode;
+
+var ERROR_COLUMNS = {name: 1, message: 1, stack: 1, columnNumber: 1, fileName: 1, lineNumber: 1};
+
+function setExtPackers(codec) {
+  codec.addExtPacker(0x0E, Error, [packError, encode]);
+  codec.addExtPacker(0x01, EvalError, [packError, encode]);
+  codec.addExtPacker(0x02, RangeError, [packError, encode]);
+  codec.addExtPacker(0x03, ReferenceError, [packError, encode]);
+  codec.addExtPacker(0x04, SyntaxError, [packError, encode]);
+  codec.addExtPacker(0x05, TypeError, [packError, encode]);
+  codec.addExtPacker(0x06, URIError, [packError, encode]);
+
+  codec.addExtPacker(0x0A, RegExp, [packRegExp, encode]);
+  codec.addExtPacker(0x0B, Boolean, [packValueOf, encode]);
+  codec.addExtPacker(0x0C, String, [packValueOf, encode]);
+  codec.addExtPacker(0x0D, Date, [Number, encode]);
+  codec.addExtPacker(0x0F, Number, [packValueOf, encode]);
+
+  if ("undefined" !== typeof Uint8Array) {
+    codec.addExtPacker(0x11, Int8Array, packTypedArray);
+    codec.addExtPacker(0x12, Uint8Array, packTypedArray);
+    codec.addExtPacker(0x13, Int16Array, packTypedArray);
+    codec.addExtPacker(0x14, Uint16Array, packTypedArray);
+    codec.addExtPacker(0x15, Int32Array, packTypedArray);
+    codec.addExtPacker(0x16, Uint32Array, packTypedArray);
+    codec.addExtPacker(0x17, Float32Array, packTypedArray);
+
+    // PhantomJS/1.9.7 doesn't have Float64Array
+    if ("undefined" !== typeof Float64Array) {
+      codec.addExtPacker(0x18, Float64Array, packTypedArray);
+    }
+
+    // IE10 doesn't have Uint8ClampedArray
+    if ("undefined" !== typeof Uint8ClampedArray) {
+      codec.addExtPacker(0x19, Uint8ClampedArray, packTypedArray);
+    }
+
+    codec.addExtPacker(0x1A, ArrayBuffer, packTypedArray);
+    codec.addExtPacker(0x1D, DataView, packTypedArray);
+  }
+
+  if (Bufferish.hasBuffer) {
+    codec.addExtPacker(0x1B, Buffer, Bufferish.from);
+  }
+}
+
+function encode(input) {
+  if (!_encode) _encode = require("./encode").encode; // lazy load
+  return _encode(input);
+}
+
+function packValueOf(value) {
+  return (value).valueOf();
+}
+
+function packRegExp(value) {
+  value = RegExp.prototype.toString.call(value).split("/");
+  value.shift();
+  var out = [value.pop()];
+  out.unshift(value.join("/"));
+  return out;
+}
+
+function packError(value) {
+  var out = {};
+  for (var key in ERROR_COLUMNS) {
+    out[key] = value[key];
+  }
+  return out;
+}

package/lib/ext-unpacker.js

@@ -0,0 +1,81 @@
+// ext-unpacker.js
+
+exports.setExtUnpackers = setExtUnpackers;
+
+var Bufferish = require("./bufferish");
+var Buffer = Bufferish.global;
+var _decode;
+
+var ERROR_COLUMNS = {name: 1, message: 1, stack: 1, columnNumber: 1, fileName: 1, lineNumber: 1};
+
+function setExtUnpackers(codec) {
+  codec.addExtUnpacker(0x0E, [decode, unpackError(Error)]);
+  codec.addExtUnpacker(0x01, [decode, unpackError(EvalError)]);
+  codec.addExtUnpacker(0x02, [decode, unpackError(RangeError)]);
+  codec.addExtUnpacker(0x03, [decode, unpackError(ReferenceError)]);
+  codec.addExtUnpacker(0x04, [decode, unpackError(SyntaxError)]);
+  codec.addExtUnpacker(0x05, [decode, unpackError(TypeError)]);
+  codec.addExtUnpacker(0x06, [decode, unpackError(URIError)]);
+
+  codec.addExtUnpacker(0x0A, [decode, unpackRegExp]);
+  codec.addExtUnpacker(0x0B, [decode, unpackClass(Boolean)]);
+  codec.addExtUnpacker(0x0C, [decode, unpackClass(String)]);
+  codec.addExtUnpacker(0x0D, [decode, unpackClass(Date)]);
+  codec.addExtUnpacker(0x0F, [decode, unpackClass(Number)]);
+
+  if ("undefined" !== typeof Uint8Array) {
+    codec.addExtUnpacker(0x11, unpackClass(Int8Array));
+    codec.addExtUnpacker(0x12, unpackClass(Uint8Array));
+    codec.addExtUnpacker(0x13, [unpackArrayBuffer, unpackClass(Int16Array)]);
+    codec.addExtUnpacker(0x14, [unpackArrayBuffer, unpackClass(Uint16Array)]);
+    codec.addExtUnpacker(0x15, [unpackArrayBuffer, unpackClass(Int32Array)]);
+    codec.addExtUnpacker(0x16, [unpackArrayBuffer, unpackClass(Uint32Array)]);
+    codec.addExtUnpacker(0x17, [unpackArrayBuffer, unpackClass(Float32Array)]);
+
+    // PhantomJS/1.9.7 doesn't have Float64Array
+    if ("undefined" !== typeof Float64Array) {
+      codec.addExtUnpacker(0x18, [unpackArrayBuffer, unpackClass(Float64Array)]);
+    }
+
+    // IE10 doesn't have Uint8ClampedArray
+    if ("undefined" !== typeof Uint8ClampedArray) {
+      codec.addExtUnpacker(0x19, unpackClass(Uint8ClampedArray));
+    }
+
+    codec.addExtUnpacker(0x1A, unpackArrayBuffer);
+    codec.addExtUnpacker(0x1D, [unpackArrayBuffer, unpackClass(DataView)]);
+  }
+
+  if (Bufferish.hasBuffer) {
+    codec.addExtUnpacker(0x1B, unpackClass(Buffer));
+  }
+}
+
+function decode(input) {
+  if (!_decode) _decode = require("./decode").decode; // lazy load
+  return _decode(input);
+}
+
+function unpackRegExp(value) {
+  return RegExp.apply(null, value);
+}
+
+function unpackError(Class) {
+  return function(value) {
+    var out = new Class();
+    for (var key in ERROR_COLUMNS) {
+      out[key] = value[key];
+    }
+    return out;
+  };
+}
+
+function unpackClass(Class) {
+  return function(value) {
+    return new Class(value);
+  };
+}
+
+function unpackArrayBuffer(value) {
+  return (new Uint8Array(value)).buffer;
+}

package/lib/ext.js

@@ -1,72 +1,7 @@
-// ext-codec.js
+// ext.js
 
-exports.Ext = Ext;
-exports.createCodec = createCodec;
+// load both interfaces
+require("./read-core");
+require("./write-core");
 
-var ExtBuffer = require("./ext-buffer").ExtBuffer;
-var IS_ARRAY = require('./is-array');
-
-function Ext() {
-  if (!(this instanceof Ext)) return new Ext();
-  this.extPackers = {};
-  this.extUnpackers = [];
-}
-
-function createCodec() {
-  return new Ext();
-}
-
-Ext.prototype.addExtPacker = function(etype, Class, packer) {
-  if (IS_ARRAY(packer)) {
-    packer = join(packer);
-  }
-  var name = Class.name;
-  if (name && name !== "Object") {
-    this.extPackers[name] = extPacker;
-  } else {
-    var list = this.extEncoderList || (this.extEncoderList = []);
-    list.unshift([Class, extPacker]);
-  }
-
-  function extPacker(value) {
-    var buffer = packer(value);
-    return new ExtBuffer(buffer, etype);
-  }
-};
-
-Ext.prototype.addExtUnpacker = function(etype, unpacker) {
-  this.extUnpackers[etype] = IS_ARRAY(unpacker) ? join(unpacker) : unpacker;
-};
-
-Ext.prototype.getExtPacker = function(value) {
-  var c = value.constructor;
-  var e = c && c.name && this.extPackers[c.name];
-  if (e) return e;
-  var list = this.extEncoderList;
-  if (!list) return;
-  var len = list.length;
-  for (var i = 0; i < len; i++) {
-    var pair = list[i];
-    if (c === pair[0]) return pair[1];
-  }
-};
-
-Ext.prototype.getExtUnpacker = function(type) {
-  return this.extUnpackers[type] || extUnpacker;
-
-  function extUnpacker(buffer) {
-    return new ExtBuffer(buffer, type);
-  }
-};
-
-function join(filters) {
-  filters = filters.slice();
-
-  return function(value) {
-    return filters.reduce(iterator, value);
-  };
-
-  function iterator(value, filter) {
-    return filter(value);
-  }
-}
+exports.createCodec = require("./codec-base").createCodec;

package/lib/flex-buffer.js

@@ -0,0 +1,194 @@
+// flex-buffer.js
+
+exports.FlexDecoder = FlexDecoder;
+exports.FlexEncoder = FlexEncoder;
+
+var Bufferish = require("./bufferish");
+
+var MIN_BUFFER_SIZE = 2048;
+var MAX_BUFFER_SIZE = 65536;
+var BUFFER_SHORTAGE = "BUFFER_SHORTAGE";
+
+function FlexDecoder() {
+  if (!(this instanceof FlexDecoder)) return new FlexDecoder();
+}
+
+function FlexEncoder() {
+  if (!(this instanceof FlexEncoder)) return new FlexEncoder();
+}
+
+FlexDecoder.mixin = mixinFactory(getDecoderMethods());
+FlexDecoder.mixin(FlexDecoder.prototype);
+
+FlexEncoder.mixin = mixinFactory(getEncoderMethods());
+FlexEncoder.mixin(FlexEncoder.prototype);
+
+function getDecoderMethods() {
+  return {
+    bufferish: Bufferish,
+    write: write,
+    fetch: fetch,
+    flush: flush,
+    push: push,
+    pull: pull,
+    read: read,
+    reserve: reserve,
+    offset: 0
+  };
+
+  function write(chunk) {
+    var prev = this.offset ? Bufferish.prototype.slice.call(this.buffer, this.offset) : this.buffer;
+    this.buffer = prev ? (chunk ? this.bufferish.concat([prev, chunk]) : prev) : chunk;
+    this.offset = 0;
+  }
+
+  function flush() {
+    while (this.offset < this.buffer.length) {
+      var start = this.offset;
+      var value;
+      try {
+        value = this.fetch();
+      } catch (e) {
+        if (e && e.message != BUFFER_SHORTAGE) throw e;
+        // rollback
+        this.offset = start;
+        break;
+      }
+      this.push(value);
+    }
+  }
+
+  function reserve(length) {
+    var start = this.offset;
+    var end = start + length;
+    if (end > this.buffer.length) throw new Error(BUFFER_SHORTAGE);
+    this.offset = end;
+    return start;
+  }
+}
+
+function getEncoderMethods() {
+  return {
+    bufferish: Bufferish,
+    write: write,
+    fetch: fetch,
+    flush: flush,
+    push: push,
+    pull: pull,
+    read: read,
+    reserve: reserve,
+    send: send,
+    maxBufferSize: MAX_BUFFER_SIZE,
+    minBufferSize: MIN_BUFFER_SIZE,
+    offset: 0,
+    start: 0
+  };
+
+  function fetch() {
+    var start = this.start;
+    if (start < this.offset) {
+      var end = this.start = this.offset;
+      return Bufferish.prototype.slice.call(this.buffer, start, end);
+    }
+  }
+
+  function flush() {
+    while (this.start < this.offset) {
+      var value = this.fetch();
+      if (value) this.push(value);
+    }
+  }
+
+  function pull() {
+    var buffers = this.buffers || (this.buffers = []);
+    var chunk = buffers.length > 1 ? this.bufferish.concat(buffers) : buffers[0];
+    buffers.length = 0; // buffer exhausted
+    return chunk;
+  }
+
+  function reserve(length) {
+    var req = length | 0;
+
+    if (this.buffer) {
+      var size = this.buffer.length;
+      var start = this.offset | 0;
+      var end = start + req;
+
+      // is it long enough?
+      if (end < size) {
+        this.offset = end;
+        return start;
+      }
+
+      // flush current buffer
+      this.flush();
+
+      // resize it to 2x current length
+      length = Math.max(length, Math.min(size * 2, this.maxBufferSize));
+    }
+
+    // minimum buffer size
+    length = Math.max(length, this.minBufferSize);
+
+    // allocate new buffer
+    this.buffer = this.bufferish.alloc(length);
+    this.start = 0;
+    this.offset = req;
+    return 0;
+  }
+
+  function send(buffer) {
+    var length = buffer.length;
+    if (length > this.minBufferSize) {
+      this.flush();
+      this.push(buffer);
+    } else {
+      var offset = this.reserve(length);
+      Bufferish.prototype.copy.call(buffer, this.buffer, offset);
+    }
+  }
+}
+
+// common methods
+
+function write() {
+  throw new Error("method not implemented: write()");
+}
+
+function fetch() {
+  throw new Error("method not implemented: fetch()");
+}
+
+function read() {
+  var length = this.buffers && this.buffers.length;
+
+  // fetch the first result
+  if (!length) return this.fetch();
+
+  // flush current buffer
+  this.flush();
+
+  // read from the results
+  return this.pull();
+}
+
+function push(chunk) {
+  var buffers = this.buffers || (this.buffers = []);
+  buffers.push(chunk);
+}
+
+function pull() {
+  var buffers = this.buffers || (this.buffers = []);
+  return buffers.shift();
+}
+
+function mixinFactory(source) {
+  return mixin;
+
+  function mixin(target) {
+    for (var key in source) {
+      target[key] = source[key];
+    }
+    return target;
+  }
+}

package/lib/read-core.js

@@ -1,31 +1,52 @@
 // read-core.js
 
-exports.decode = decode;
-exports.decodeAsync = decodeAsync;
-
-var uint8 = require("./read-format").format.uint8;
-var token = require("./read-token").token;
-var BUFFER_SHORTAGE = require("./common").BUFFER_SHORTAGE;
-
-function decode(decoder) {
-  var type = uint8(decoder);
-  var func = token[type];
-  if (!func) throw new Error("Invalid type: " + (type ? ("0x" + type.toString(16)) : type));
-  return func(decoder);
+var ExtBuffer = require("./ext-buffer").ExtBuffer;
+var ExtUnpacker = require("./ext-unpacker");
+var readUint8 = require("./read-format").readUint8;
+var ReadToken = require("./read-token");
+var CodecBase = require("./codec-base");
+
+CodecBase.install({
+  addExtUnpacker: addExtUnpacker,
+  getExtUnpacker: getExtUnpacker,
+  init: init
+});
+
+exports.preset = init.call(CodecBase.preset);
+
+function getDecoder(options) {
+  var readToken = ReadToken.getReadToken(options);
+  return decode;
+
+  function decode(decoder) {
+    var type = readUint8(decoder);
+    var func = readToken[type];
+    if (!func) throw new Error("Invalid type: " + (type ? ("0x" + type.toString(16)) : type));
+    return func(decoder);
+  }
 }
 
-function decodeAsync(decoder) {
-  while (decoder.offset < decoder.buffer.length) {
-    var start = decoder.offset;
-    var value;
-    try {
-      value = decode(decoder);
-    } catch (e) {
-      if (e !== BUFFER_SHORTAGE) throw e;
-      // rollback
-      decoder.offset = start;
-      break;
-    }
-    decoder.push(value);
+function init() {
+  var options = this.options;
+  this.decode = getDecoder(options);
+
+  if (options && options.preset) {
+    ExtUnpacker.setExtUnpackers(this);
+  }
+
+  return this;
+}
+
+function addExtUnpacker(etype, unpacker) {
+  var unpackers = this.extUnpackers || (this.extUnpackers = []);
+  unpackers[etype] = CodecBase.filter(unpacker);
+}
+
+function getExtUnpacker(type) {
+  var unpackers = this.extUnpackers || (this.extUnpackers = []);
+  return unpackers[type] || extUnpacker;
+
+  function extUnpacker(buffer) {
+    return new ExtBuffer(buffer, type);
   }
 }