passim: eslint new-cap, update minimum Node version to 4.5

We need the safe Buffer API which became availble in 4.5.0.

Author: pabigot

.eslintrc.js

@@ -9,7 +9,6 @@ module.exports = {
   ],
   rules: {
     'guard-for-in': 'off',
-    'new-cap': 'off',
     'prefer-rest-params': 'off',
     'prefer-spread': 'off',
     __temporary: 'off',

README.md

@@ -28,9 +28,8 @@ Layout support is provided for these types of data:
 
 ## Installation
 
-Development and testing is done using Node.js, supporting versions 4 and
-later (earlier versions may work).  Install with `npm install
-buffer-layout`.
+Development and testing is done using Node.js, supporting versions 4.5
+and later.  Install with `npm install buffer-layout`.
 
 ## Examples
 
@@ -58,9 +57,9 @@ The C definition:
 The buffer-layout way:
 
     const ds = lo.seq(lo.s16(), 4);
-    const b = new Buffer(8);
+    const b = Buffer.alloc(8);
     assert.equal(ds.encode([1, -1, 3, -3], b), 4 * 2);
-    assert.equal(Buffer('0100ffff0300fdff', 'hex').compare(b), 0);
+    assert.equal(Buffer.from('0100ffff0300fdff', 'hex').compare(b), 0);
     assert.deepEqual(ds.decode(b), [1, -1, 3, -3]);
 
 See [Int](http://pabigot.github.io/buffer-layout/module-Layout-Int.html)
@@ -81,10 +80,10 @@ The buffer-layout way:
                         lo.seq(lo.u8(), 3), // alignment padding
                         lo.u32('u32')]);
     assert.equal(ds.offsetOf('u32'), 4);
-    const b = new Buffer(8);
+    const b = Buffer.alloc(8);
     b.fill(0xbd);
     assert.equal(ds.encode({v: 1, u32: 0x12345678}, b), 1 + 3 + 4);
-    assert.equal(Buffer('01bdbdbd78563412', 'hex').compare(b), 0);
+    assert.equal(Buffer.from('01bdbdbd78563412', 'hex').compare(b), 0);
     assert.deepEqual(ds.decode(b), {v: 1, u32: 0x12345678});
 
 Note that the C language requires padding which must be explicitly added
@@ -108,10 +107,10 @@ The buffer-layout way:
     const ds = lo.struct([lo.u8('v'),
                         lo.u32('u32')]);
     assert.equal(ds.offsetOf('u32'), 1);
-    const b = new Buffer(5);
+    const b = Buffer.alloc(5);
     b.fill(0xbd);
     assert.equal(ds.encode({v: 1, u32: 0x12345678}, b), 1 + 4);
-    assert.equal(Buffer('0178563412', 'hex').compare(b), 0);
+    assert.equal(Buffer.from('0178563412', 'hex').compare(b), 0);
     assert.deepEqual(ds.decode(b), {v: 1, u32: 0x12345678});
 
 ### A tagged union of 4-byte values
@@ -136,15 +135,15 @@ The buffer-layout way:
     const u32 = un.addVariant('w'.charCodeAt(0), lo.u32(), 'u32');
     const s16 = un.addVariant('h'.charCodeAt(0), lo.seq(lo.s16(), 2), 's16');
     const f32 = un.addVariant('f'.charCodeAt(0), lo.f32(), 'f32');
-    const b = new Buffer(un.span);
-    assert.deepEqual(un.decode(Buffer('7778563412', 'hex')),
+    const b = Buffer.alloc(un.span);
+    assert.deepEqual(un.decode(Buffer.from('7778563412', 'hex')),
                      {u32: 0x12345678});
-    assert.deepEqual(un.decode(Buffer('660000bd41', 'hex')),
+    assert.deepEqual(un.decode(Buffer.from('660000bd41', 'hex')),
                      {f32: 23.625});
-    assert.deepEqual(un.decode(Buffer('a5a5a5a5a5', 'hex')),
+    assert.deepEqual(un.decode(Buffer.from('a5a5a5a5a5', 'hex')),
                      {t: 0xa5, u8: [0xa5, 0xa5, 0xa5, 0xa5]});
     assert.equal(s16.encode({s16: [123, -123]}, b), 1 + 2 * 2);
-    assert.equal(Buffer('687b0085ff', 'hex').compare(b), 0);
+    assert.equal(Buffer.from('687b0085ff', 'hex').compare(b), 0);
 
 See [Union](http://pabigot.github.io/buffer-layout/module-Layout-Union.html).
 
@@ -172,20 +171,20 @@ representing the union and the variants:
     lo.bindConstructorLayout(Vf32,
                              Union.layout_.addVariant('f'.charCodeAt(0), lo.f32(), 'f32'));
 
-    let v = Union.decode(Buffer('7778563412', 'hex'));
+    let v = Union.decode(Buffer.from('7778563412', 'hex'));
     assert(v instanceof Vu32);
     assert(v instanceof Union);
     assert.equal(v.u32, 0x12345678);
 
-    v = Union.decode(Buffer('a5a5a5a5a5', 'hex'));
+    v = Union.decode(Buffer.from('a5a5a5a5a5', 'hex'));
     assert(v instanceof Union);
     assert.equal(v.t, 0xa5);
     assert.deepEqual(v.u8, [0xa5, 0xa5, 0xa5, 0xa5]);
 
-    const b = new Buffer(Union.layout_.span);
+    const b = Buffer.alloc(Union.layout_.span);
     v = new Vf32(23.625);
     v.encode(b);
-    assert.equal(Buffer('660000bd41', 'hex').compare(b), 0);
+    assert.equal(Buffer.from('660000bd41', 'hex').compare(b), 0);
 
 See
 [Layout.makeDestinationObject()](http://pabigot.github.io/buffer-layout/module-Layout-Layout.html#makeDestinationObject)
@@ -206,14 +205,14 @@ The C definition:
 The buffer-layout way:
 
     const ds = lo.bits(lo.u32());
-    const b = new Buffer(4);
+    const b = Buffer.alloc(4);
     ds.addField(3, 'b00l03');
     ds.addBoolean('flg03');
     ds.addField(24, 'b04l18');
     ds.addField(4, 'b1Cl04');
     b.fill(0xff);
     assert.equal(ds.encode({b00l03: 3, b04l18: 24, b1Cl04: 4}, b), 4);
-    assert.equal(Buffer('8b010040', 'hex').compare(b), 0);
+    assert.equal(Buffer.from('8b010040', 'hex').compare(b), 0);
     assert.deepEqual(ds.decode(b),
                      {b00l03: 3, flg03: true, b04l18: 24, b1Cl04: 4});
 
@@ -228,7 +227,7 @@ The C definition:
 The buffer-layout way:
 
     const ds = lo.nu64be();
-    const b = Buffer('0102030405060708', 'hex');
+    const b = Buffer.from('0102030405060708', 'hex');
     const v = 72623859790382856;
     const nv = v - 6;
     assert.equal(v, nv);
@@ -249,11 +248,11 @@ The C definition:
 The buffer-layout way:
 
     const ds = lo.cstr();
-    const b = new Buffer(8);
+    const b = Buffer.alloc(8);
     assert.equal(ds.encode('hi!', b), 3 + 1);
     const slen = ds.getSpan(b);
     assert.equal(slen, 4);
-    assert.equal(Buffer('68692100', 'hex').compare(b.slice(0, slen)), 0);
+    assert.equal(Buffer.from('68692100', 'hex').compare(b.slice(0, slen)), 0);
     assert.equal(ds.decode(b), 'hi!');
 
 See [CString](http://pabigot.github.io/buffer-layout/module-Layout-CString.html).
@@ -263,8 +262,8 @@ See [CString](http://pabigot.github.io/buffer-layout/module-Layout-CString.html)
 The buffer-layout way:
 
     const ds = lo.blob(4);
-    const b = Buffer('0102030405060708', 'hex');
-    assert.equal(Buffer('03040506', 'hex').compare(ds.decode(b, 2)), 0);
+    const b = Buffer.from('0102030405060708', 'hex');
+    assert.equal(Buffer.from('03040506', 'hex').compare(ds.decode(b, 2)), 0);
 
 See [Blob](http://pabigot.github.io/buffer-layout/module-Layout-Blob.html).
 
@@ -276,13 +275,14 @@ The buffer-layout way:
     const n = lo.u8('n');
     const vla = lo.seq(pr, lo.offset(n, -1), 'a');
     const st = lo.struct([n, vla], 'st');
-    const b = new Buffer(32);
+    const b = Buffer.alloc(32);
     const arr = [['k1', 'v1'], ['k2', 'v2'], ['k3', 'etc']];
     b.fill(0);
-    assert.equal(st.encode({a: arr}, b), 1 + (2 * ((2 + 1) + (2 + 1)) + (2 + 1) + (3 + 1)));
+    assert.equal(st.encode({a: arr}, b),
+                 1 + (2 * ((2 + 1) + (2 + 1)) + (2 + 1) + (3 + 1)));
     const span = st.getSpan(b);
     assert.equal(span, 20);
-    assert.equal(Buffer('036b31007631006b32007632006b330065746300', 'hex')
+    assert.equal(Buffer.from('036b31007631006b32007632006b330065746300', 'hex')
                  .compare(b.slice(0, span)), 0);
     assert.deepEqual(st.decode(b), {n: 3, a: arr});
 
@@ -307,11 +307,11 @@ The buffer-layout way:
                                lo.greedy(lo.u16().span),
                                'data')],
                        'ds');
-    const b = Buffer('21010002030405', 'hex');
+    const b = Buffer.from('21010002030405', 'hex');
     assert.deepEqual(st.decode(b), {prop: 33, data: [0x0001, 0x0302, 0x0504]});
     b.fill(0xFF);
-    assert.equal(st.encode({prop: 9, data: [5,6]}, b), 1 + 2 * 2);
-    assert.equal(Buffer('0905000600FFFF', 'hex').compare(b), 0);
+    assert.equal(st.encode({prop: 9, data: [5, 6]}, b), 1 + 2 * 2);
+    assert.equal(Buffer.from('0905000600FFFF', 'hex').compare(b), 0);
 
 ### Tagged values, or variable-length unions
 
@@ -333,7 +333,7 @@ recognition of `true` and `false` values for `b` as distinct variants:
     const cstr = un.addVariant('s'.charCodeAt(0), lo.cstr(), 'str');
     const tr = un.addVariant('T'.charCodeAt(0), lo.const(true), 'b');
     const fa = un.addVariant('F'.charCodeAt(0), lo.const(false), 'b');
-    const b = new Buffer(1 + 6);
+    const b = Buffer.alloc(1 + 6);
     un.configGetSourceVariant(function(src) {
       if (src.hasOwnProperty('b')) {
         return src.b ? tr : fa;
@@ -347,36 +347,34 @@ decoding each of the alternatives:
     b.fill(0xff);
     assert.equal(un.encode({u8: 1}, b), 1 + 1);
     assert.equal(un.getSpan(b), 2);
-    assert.equal(Buffer('4201ffffffffff', 'hex').compare(b), 0);
+    assert.equal(Buffer.from('4201ffffffffff', 'hex').compare(b), 0);
     assert.equal(un.decode(b).u8, 1);
 
     b.fill(0xff);
     assert.equal(un.encode({s16: -32000}, b), 1 + 2);
     assert.equal(un.getSpan(b), 3);
-    assert.equal(Buffer('680083ffffffff', 'hex').compare(b), 0);
+    assert.equal(Buffer.from('680083ffffffff', 'hex').compare(b), 0);
     assert.equal(un.decode(b).s16, -32000);
 
     b.fill(0xff);
     const v48 = Math.pow(2, 47) - 1;
     assert.equal(un.encode({s48: v48}, b), 1 + 6);
     assert.equal(un.getSpan(b), 7);
-    assert.equal(Buffer('51ffffffffff7f', 'hex').compare(b), 0);
+    assert.equal(Buffer.from('51ffffffffff7f', 'hex').compare(b), 0);
     assert.equal(un.decode(b).s48, v48);
 
     b.fill(0xff);
     assert.equal(un.encode({b: true}, b), 1);
     assert.equal(un.getSpan(b), 1);
-    assert.equal(Buffer('54ffffffffffff', 'hex').compare(b), 0);
+    assert.equal(Buffer.from('54ffffffffffff', 'hex').compare(b), 0);
     assert.strictEqual(un.decode(b).b, true);
 
     b.fill(0xff);
     assert.equal(un.encode({b: false}, b), 1);
     assert.equal(un.getSpan(b), 1);
-    assert.equal(Buffer('46ffffffffffff', 'hex').compare(b), 0);
+    assert.equal(Buffer.from('46ffffffffffff', 'hex').compare(b), 0);
     assert.strictEqual(un.decode(b).b, false);
 
 **NOTE** This code tickles a long-standing [bug in
-Buffer.writeInt{L,B}E](https://github.com/nodejs/node/pull/3994). `buffer-layout`
-provides a [module that patches
-`Buffer`](http://pabigot.github.io/buffer-layout/module-patchIssue3992.html)
-to fix the bug if it detects that the running Node has the error.
+Buffer.writeInt{L,B}E](https://github.com/nodejs/node/pull/3994); if you
+are using Node prior to 4.2.4 or 5.2.0 you should update.

lib/Layout.js

@@ -133,8 +133,6 @@
 
 const assert = require('assert');
 
-require('./patchIssue3992');
-
 /**
  * Base class for layout objects.
  *
@@ -328,58 +326,59 @@ function nameWithProperty(name, lo) {
 exports.nameWithProperty = nameWithProperty;
 
 /**
- * Augment a constructor so that instances can be encoded/decoded
- * using a given layout.
+ * Augment a class so that instances can be encoded/decoded using a
+ * given layout.
  *
- * Calling this function couples `ctor` with `layout` in several ways:
+ * Calling this function couples `Class` with `layout` in several ways:
  *
- * * `ctor.layout_` becomes a static member property equal to `layout`;
+ * * `Class.layout_` becomes a static member property equal to `layout`;
  * * `layout.boundConstructor_` becomes a static member property equal
- *    to `ctor`;
+ *    to `Class`;
  * * The {@link Layout#makeDestinationObject|makeDestinationObject()}
  *   property of `layout` is set to a function that returns a `new
- *   ctor()`;
- * * `ctor.decode(b, offset)` becomes a static member function that
+ *   Class()`;
+ * * `Class.decode(b, offset)` becomes a static member function that
  *   delegates to {@link Layout#decode|layout.decode}.  The
  *   synthesized function may be captured and extended.
- * * `ctor.prototype.encode(b, offset)` provides an instance member
+ * * `Class.prototype.encode(b, offset)` provides an instance member
  *   function that delegates to {@link Layout#encode|layout.encode}
  *   with `src` set to `this`.  The synthesized function may be
  *   captured and extended, but when the extension is invoked `this`
  *   must be explicitly bound to the instance.
  *
- * @param {constructor} ctor - the constructor for a JavaScript class.
+ * @param {class} Class - a JavaScript class with a nullary
+ * constructor.
  *
  * @param {Layout} layout - the {@link Layout|Layout} instance used to
- * encode instances of `ctor`.
+ * encode instances of `Class`.
  */
-exports.bindConstructorLayout = function(ctor, layout) {
-  if ('function' !== typeof ctor) {
-    throw new TypeError('ctor must be constructor');
+exports.bindConstructorLayout = function(Class, layout) {
+  if ('function' !== typeof Class) {
+    throw new TypeError('Class must be constructor');
   }
-  if (ctor.hasOwnProperty('layout_')) {
-    throw new Error('ctor is already bound to a layout');
+  if (Class.hasOwnProperty('layout_')) {
+    throw new Error('Class is already bound to a layout');
   }
   if (!(layout && (layout instanceof Layout))) {
     throw new TypeError('layout must be a Layout');
   }
   if (layout.hasOwnProperty('boundConstructor_')) {
     throw new Error('layout is already bound to a constructor');
   }
-  ctor.layout_ = layout;
-  layout.boundConstructor_ = ctor;
+  Class.layout_ = layout;
+  layout.boundConstructor_ = Class;
   layout.makeDestinationObject = function() {
-    return new ctor();
+    return new Class();
   };
-  Object.defineProperty(ctor.prototype, 'encode', {
+  Object.defineProperty(Class.prototype, 'encode', {
     configurable: false,
     enumerable: false,
     value: function(b, offset) {
       return layout.encode(this, b, offset);
     },
     writable: true,
   });
-  Object.defineProperty(ctor, 'decode', {
+  Object.defineProperty(Class, 'decode', {
     configurable: false,
     enumerable: false,
     value: function(b, offset) {