chromium-pickle-js - npm Package Compare versions

Comparing version 0.1.0 to 0.2.0

lib/exports.js

@@ -1,15 +0,11 @@
-(function() {
-  var Pickle;
+var Pickle = require('./pickle')
 
-  Pickle = require('./pickle');
+module.exports = {
+  createEmpty: function () {
+    return new Pickle()
+  },
 
-  module.exports = {
-    createEmpty: function() {
-      return new Pickle;
-    },
-    createFromBuffer: function(buffer) {
-      return new Pickle(buffer);
-    }
-  };
-
-}).call(this);
+  createFromBuffer: function (buffer) {
+    return new Pickle(buffer)
+  }
+}

lib/pickle.js

@@ -1,215 +0,222 @@
-(function() {
-  var CAPACITY_READ_ONLY, PAYLOAD_UNIT, Pickle, PickleIterator, SIZE_DOUBLE, SIZE_FLOAT, SIZE_INT32, SIZE_INT64, SIZE_UINT32, SIZE_UINT64, alignInt;
+// sizeof(T).
+var SIZE_INT32 = 4
+var SIZE_UINT32 = 4
+var SIZE_INT64 = 8
+var SIZE_UINT64 = 8
+var SIZE_FLOAT = 4
+var SIZE_DOUBLE = 8
 
-  SIZE_INT32 = 4;
+// The allocation granularity of the payload.
+var PAYLOAD_UNIT = 64
 
-  SIZE_UINT32 = 4;
+// Largest JS number.
+var CAPACITY_READ_ONLY = 9007199254740992
 
-  SIZE_INT64 = 8;
+// Aligns 'i' by rounding it up to the next multiple of 'alignment'.
+var alignInt = function (i, alignment) {
+  return i + (alignment - (i % alignment)) % alignment
+}
 
-  SIZE_UINT64 = 8;
+// PickleIterator reads data from a Pickle. The Pickle object must remain valid
+// while the PickleIterator object is in use.
+var PickleIterator = (function () {
+  function PickleIterator (pickle) {
+    this.payload = pickle.header
+    this.payloadOffset = pickle.headerSize
+    this.readIndex = 0
+    this.endIndex = pickle.getPayloadSize()
+  }
 
-  SIZE_FLOAT = 4;
+  PickleIterator.prototype.readBool = function () {
+    return this.readInt() !== 0
+  }
 
-  SIZE_DOUBLE = 8;
+  PickleIterator.prototype.readInt = function () {
+    return this.readBytes(SIZE_INT32, Buffer.prototype.readInt32LE)
+  }
 
-  PAYLOAD_UNIT = 64;
+  PickleIterator.prototype.readUInt32 = function () {
+    return this.readBytes(SIZE_UINT32, Buffer.prototype.readUInt32LE)
+  }
 
-  CAPACITY_READ_ONLY = 9007199254740992;
+  PickleIterator.prototype.readInt64 = function () {
+    return this.readBytes(SIZE_INT64, Buffer.prototype.readInt64LE)
+  }
 
-  alignInt = function(i, alignment) {
-    return i + (alignment - (i % alignment)) % alignment;
-  };
+  PickleIterator.prototype.readUInt64 = function () {
+    return this.readBytes(SIZE_UINT64, Buffer.prototype.readUInt64LE)
+  }
 
-  PickleIterator = (function() {
-    function PickleIterator(pickle) {
-      this.payload = pickle.header;
-      this.payloadOffset = pickle.headerSize;
-      this.readIndex = 0;
-      this.endIndex = pickle.getPayloadSize();
-    }
+  PickleIterator.prototype.readFloat = function () {
+    return this.readBytes(SIZE_FLOAT, Buffer.prototype.readFloatLE)
+  }
 
-    PickleIterator.prototype.readBool = function() {
-      return this.readInt() !== 0;
-    };
+  PickleIterator.prototype.readDouble = function () {
+    return this.readBytes(SIZE_DOUBLE, Buffer.prototype.readDoubleLE)
+  }
 
-    PickleIterator.prototype.readInt = function() {
-      return this.readBytes(SIZE_INT32, Buffer.prototype.readInt32LE);
-    };
+  PickleIterator.prototype.readString = function () {
+    return this.readBytes(this.readInt()).toString()
+  }
 
-    PickleIterator.prototype.readUInt32 = function() {
-      return this.readBytes(SIZE_UINT32, Buffer.prototype.readUInt32LE);
-    };
+  PickleIterator.prototype.readBytes = function (length, method) {
+    var readPayloadOffset = this.getReadPayloadOffsetAndAdvance(length)
+    if (method != null) {
+      return method.call(this.payload, readPayloadOffset, length)
+    } else {
+      return this.payload.slice(readPayloadOffset, readPayloadOffset + length)
+    }
+  }
 
-    PickleIterator.prototype.readInt64 = function() {
-      return this.readBytes(SIZE_INT64, Buffer.prototype.readInt64LE);
-    };
+  PickleIterator.prototype.getReadPayloadOffsetAndAdvance = function (length) {
+    if (length > this.endIndex - this.readIndex) {
+      this.readIndex = this.endIndex
+      throw new Error('Failed to read data with length of ' + length)
+    }
+    var readPayloadOffset = this.payloadOffset + this.readIndex
+    this.advance(length)
+    return readPayloadOffset
+  }
 
-    PickleIterator.prototype.readUInt64 = function() {
-      return this.readBytes(SIZE_UINT64, Buffer.prototype.readUInt64LE);
-    };
+  PickleIterator.prototype.advance = function (size) {
+    var alignedSize = alignInt(size, SIZE_UINT32)
+    if (this.endIndex - this.readIndex < alignedSize) {
+      this.readIndex = this.endIndex
+    } else {
+      this.readIndex += alignedSize
+    }
+  }
 
-    PickleIterator.prototype.readFloat = function() {
-      return this.readBytes(SIZE_FLOAT, Buffer.prototype.readFloatLE);
-    };
+  return PickleIterator
+})()
 
-    PickleIterator.prototype.readDouble = function() {
-      return this.readBytes(SIZE_DOUBLE, Buffer.prototype.readDoubleLE);
-    };
+// This class provides facilities for basic binary value packing and unpacking.
+//
+// The Pickle class supports appending primitive values (ints, strings, etc.)
+// to a pickle instance.  The Pickle instance grows its internal memory buffer
+// dynamically to hold the sequence of primitive values.   The internal memory
+// buffer is exposed as the "data" of the Pickle.  This "data" can be passed
+// to a Pickle object to initialize it for reading.
+//
+// When reading from a Pickle object, it is important for the consumer to know
+// what value types to read and in what order to read them as the Pickle does
+// not keep track of the type of data written to it.
+//
+// The Pickle's data has a header which contains the size of the Pickle's
+// payload.  It can optionally support additional space in the header.  That
+// space is controlled by the header_size parameter passed to the Pickle
+// constructor.
+var Pickle = (function () {
+  function Pickle (buffer) {
+    if (buffer) {
+      this.initFromBuffer(buffer)
+    } else {
+      this.initEmpty()
+    }
+  }
 
-    PickleIterator.prototype.readString = function() {
-      return this.readBytes(this.readInt()).toString();
-    };
+  Pickle.prototype.initEmpty = function () {
+    this.header = new Buffer(0)
+    this.headerSize = SIZE_UINT32
+    this.capacityAfterHeader = 0
+    this.writeOffset = 0
+    this.resize(PAYLOAD_UNIT)
+    this.setPayloadSize(0)
+  }
 
-    PickleIterator.prototype.readBytes = function(length, method) {
-      var readPayloadOffset;
-      readPayloadOffset = this.getReadPayloadOffsetAndAdvance(length);
-      if (method != null) {
-        return method.call(this.payload, readPayloadOffset, length);
-      } else {
-        return this.payload.slice(readPayloadOffset, readPayloadOffset + length);
-      }
-    };
-
-    PickleIterator.prototype.getReadPayloadOffsetAndAdvance = function(length) {
-      var readPayloadOffset;
-      if (length > this.endIndex - this.readIndex) {
-        this.readIndex = this.endIndex;
-        throw new Error("Failed to read data with length of " + length);
-      }
-      readPayloadOffset = this.payloadOffset + this.readIndex;
-      this.advance(length);
-      return readPayloadOffset;
-    };
-
-    PickleIterator.prototype.advance = function(size) {
-      var alignedSize;
-      alignedSize = alignInt(size, SIZE_UINT32);
-      if (this.endIndex - this.readIndex < alignedSize) {
-        return this.readIndex = this.endIndex;
-      } else {
-        return this.readIndex += alignedSize;
-      }
-    };
-
-    return PickleIterator;
-
-  })();
-
-  Pickle = (function() {
-    function Pickle(buffer) {
-      if (buffer) {
-        this.initFromBuffer(buffer);
-      } else {
-        this.initEmpty();
-      }
+  Pickle.prototype.initFromBuffer = function (buffer) {
+    this.header = buffer
+    this.headerSize = buffer.length - this.getPayloadSize()
+    this.capacityAfterHeader = CAPACITY_READ_ONLY
+    this.writeOffset = 0
+    if (this.headerSize > buffer.length) {
+      this.headerSize = 0
     }
+    if (this.headerSize !== alignInt(this.headerSize, SIZE_UINT32)) {
+      this.headerSize = 0
+    }
+    if (this.headerSize === 0) {
+      this.header = new Buffer(0)
+    }
+  }
 
-    Pickle.prototype.initEmpty = function() {
-      this.header = new Buffer(0);
-      this.headerSize = SIZE_UINT32;
-      this.capacityAfterHeader = 0;
-      this.writeOffset = 0;
-      this.resize(PAYLOAD_UNIT);
-      return this.setPayloadSize(0);
-    };
+  Pickle.prototype.createIterator = function () {
+    return new PickleIterator(this)
+  }
 
-    Pickle.prototype.initFromBuffer = function(buffer) {
-      this.header = buffer;
-      this.headerSize = buffer.length - this.getPayloadSize();
-      this.capacityAfterHeader = CAPACITY_READ_ONLY;
-      this.writeOffset = 0;
-      if (this.headerSize > buffer.length) {
-        this.headerSize = 0;
-      }
-      if (this.headerSize !== alignInt(this.headerSize, SIZE_UINT32)) {
-        this.headerSize = 0;
-      }
-      if (this.headerSize === 0) {
-        return this.header = new Buffer(0);
-      }
-    };
+  Pickle.prototype.toBuffer = function () {
+    return this.header.slice(0, this.headerSize + this.getPayloadSize())
+  }
 
-    Pickle.prototype.createIterator = function() {
-      return new PickleIterator(this);
-    };
+  Pickle.prototype.writeBool = function (value) {
+    return this.writeInt(value ? 1 : 0)
+  }
 
-    Pickle.prototype.toBuffer = function() {
-      return this.header.slice(0, this.headerSize + this.getPayloadSize());
-    };
+  Pickle.prototype.writeInt = function (value) {
+    return this.writeBytes(value, SIZE_INT32, Buffer.prototype.writeInt32LE)
+  }
 
-    Pickle.prototype.writeBool = function(value) {
-      return this.writeInt(value ? 1 : 0);
-    };
+  Pickle.prototype.writeUInt32 = function (value) {
+    return this.writeBytes(value, SIZE_UINT32, Buffer.prototype.writeUInt32LE)
+  }
 
-    Pickle.prototype.writeInt = function(value) {
-      return this.writeBytes(value, SIZE_INT32, Buffer.prototype.writeInt32LE);
-    };
+  Pickle.prototype.writeInt64 = function (value) {
+    return this.writeBytes(value, SIZE_INT64, Buffer.prototype.writeInt64LE)
+  }
 
-    Pickle.prototype.writeUInt32 = function(value) {
-      return this.writeBytes(value, SIZE_UINT32, Buffer.prototype.writeUInt32LE);
-    };
+  Pickle.prototype.writeUInt64 = function (value) {
+    return this.writeBytes(value, SIZE_UINT64, Buffer.prototype.writeUInt64LE)
+  }
 
-    Pickle.prototype.writeInt64 = function(value) {
-      return this.writeBytes(value, SIZE_INT64, Buffer.prototype.writeInt64LE);
-    };
+  Pickle.prototype.writeFloat = function (value) {
+    return this.writeBytes(value, SIZE_FLOAT, Buffer.prototype.writeFloatLE)
+  }
 
-    Pickle.prototype.writeUInt64 = function(value) {
-      return this.writeBytes(value, SIZE_UINT64, Buffer.prototype.writeUInt64LE);
-    };
+  Pickle.prototype.writeDouble = function (value) {
+    return this.writeBytes(value, SIZE_DOUBLE, Buffer.prototype.writeDoubleLE)
+  }
 
-    Pickle.prototype.writeFloat = function(value) {
-      return this.writeBytes(value, SIZE_FLOAT, Buffer.prototype.writeFloatLE);
-    };
+  Pickle.prototype.writeString = function (value) {
+    var length = Buffer.byteLength(value, 'utf8')
+    if (!this.writeInt(length)) {
+      return false
+    }
+    return this.writeBytes(value, length)
+  }
 
-    Pickle.prototype.writeDouble = function(value) {
-      return this.writeBytes(value, SIZE_DOUBLE, Buffer.prototype.writeDoubleLE);
-    };
+  Pickle.prototype.setPayloadSize = function (payloadSize) {
+    return this.header.writeUInt32LE(payloadSize, 0)
+  }
 
-    Pickle.prototype.writeString = function(value) {
-      if (!this.writeInt(value.length)) {
-        return false;
-      }
-      return this.writeBytes(value, value.length);
-    };
+  Pickle.prototype.getPayloadSize = function () {
+    return this.header.readUInt32LE(0)
+  }
 
-    Pickle.prototype.setPayloadSize = function(payloadSize) {
-      return this.header.writeUInt32LE(payloadSize, 0);
-    };
+  Pickle.prototype.writeBytes = function (data, length, method) {
+    var dataLength = alignInt(length, SIZE_UINT32)
+    var newSize = this.writeOffset + dataLength
+    if (newSize > this.capacityAfterHeader) {
+      this.resize(Math.max(this.capacityAfterHeader * 2, newSize))
+    }
+    if (method != null) {
+      method.call(this.header, data, this.headerSize + this.writeOffset)
+    } else {
+      this.header.write(data, this.headerSize + this.writeOffset, length)
+    }
+    var endOffset = this.headerSize + this.writeOffset + length
+    this.header.fill(0, endOffset, endOffset + dataLength - length)
+    this.setPayloadSize(newSize)
+    this.writeOffset = newSize
+    return true
+  }
 
-    Pickle.prototype.getPayloadSize = function() {
-      return this.header.readUInt32LE(0);
-    };
+  Pickle.prototype.resize = function (newCapacity) {
+    newCapacity = alignInt(newCapacity, PAYLOAD_UNIT)
+    this.header = Buffer.concat([this.header, new Buffer(newCapacity)])
+    this.capacityAfterHeader = newCapacity
+  }
 
-    Pickle.prototype.writeBytes = function(data, length, method) {
-      var dataLength, endOffset, newSize;
-      dataLength = alignInt(length, SIZE_UINT32);
-      newSize = this.writeOffset + dataLength;
-      if (newSize > this.capacityAfterHeader) {
-        this.resize(Math.max(this.capacityAfterHeader * 2, newSize));
-      }
-      if (method != null) {
-        method.call(this.header, data, this.headerSize + this.writeOffset);
-      } else {
-        this.header.write(data, this.headerSize + this.writeOffset, length);
-      }
-      endOffset = this.headerSize + this.writeOffset + length;
-      this.header.fill(0, endOffset, endOffset + dataLength - length);
-      this.setPayloadSize(newSize);
-      this.writeOffset = newSize;
-      return true;
-    };
+  return Pickle
+})()
 
-    Pickle.prototype.resize = function(newCapacity) {
-      newCapacity = alignInt(newCapacity, PAYLOAD_UNIT);
-      this.header = Buffer.concat([this.header, new Buffer(newCapacity)]);
-      return this.capacityAfterHeader = newCapacity;
-    };
-
-    return Pickle;
-
-  })();
-
-  module.exports = Pickle;
-
-}).call(this);
+module.exports = Pickle

package.json

@@ -5,29 +5,18 @@ {
   "description": "Binary value packing and unpacking",
-  "version": "0.1.0",
-  "licenses": [
-    {
-      "type": "MIT",
-      "url": "http://github.com/atom/node-chromium-pickle-js/raw/master/LICENSE"
-    }
-  ],
+  "version": "0.2.0",
+  "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/atom/node-chromium-pickle-js.git"
+    "url": "https://github.com/electron/node-chromium-pickle-js.git"
   },
   "bugs": {
-    "url": "https://github.com/atom/node-chromium-pickle-js/issues"
+    "url": "https://github.com/electron/node-chromium-pickle-js/issues"
   },
   "scripts": {
-    "prepublish": "grunt coffee"
+    "test": "mocha test && standard"
   },
   "devDependencies": {
-    "grunt": "~0.4.1",
-    "grunt-coffeelint": "0.0.6",
-    "grunt-contrib-coffee": "~0.6.6",
-    "grunt-cli": "~0.1.7",
-    "coffee-script": "~1.6.2",
-    "rimraf": "~2.1.4"
-  },
-  "dependencies": {
+    "mocha": "^3.0.2",
+    "standard": "^8.0.0"
   }
 }

README.md

@@ -1,2 +0,2 @@
-# chromium-pickle-js
+# chromium-pickle-js [![Build Status](https://travis-ci.org/electron/node-chromium-pickle-js.svg?branch=master)](https://travis-ci.org/electron/node-chromium-pickle-js)
 
@@ -3,0 +3,0 @@ This module ports Chromium's `Pickle` class to Node, see `Pickle`'s header for

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

No bug tracker

Maintenance

Package does not have a linked bug tracker in package.json.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

11695

increased by0.43%

Dev dependency count

2

decreased by-66.67%

Lines of code

196

increased by0.51%

Number of low maintenance alerts

2

decreased by-33.33%

Worsened metrics

Number of package files

4

decreased by-20%

Number of medium supply chain risk alerts

2

increased byInfinity%

No dependency changes