Suspendable: adds class that provides a "pause" and "resume" method

We can't safely or effectively destroy objects that represent hardware or hardware states, but we need a way to temporarily prevent sensors from emitting data events. This class will move the contents of _events into a side table weakmap when pause() is called and then restore _events when resume() is called.

Author: rwaldron

.jshintrc

@@ -14,6 +14,7 @@
   "strict": false,
   "quotmark": "double",
   "unused": true,
+  "proto": true,
   "globals": {
     "exports": true,
     "document": true,

lib/light.js

@@ -1,6 +1,6 @@
 const Board = require("./board");
 const EVS = require("./evshield");
-const Withinable = require("./mixins/within");
+const Suspendable = require("./mixins/suspendable");
 const { uint16, toFixed, scale } = require("./fn");
 const priv = new Map();
 
@@ -436,7 +436,7 @@ Controllers.ALSPT19 = Controllers["ALS-PT19"] = Controllers.DEFAULT;
  *
  */
 
-class Light extends Withinable {
+class Light extends Suspendable {
   constructor(options) {
     super();
 

lib/mixins/suspendable.js

@@ -0,0 +1,26 @@
+const Withinable = require("./withinable");
+const wm = new WeakMap();
+
+class Suspendable extends Withinable {
+  pause() {
+
+    wm.set(this, {
+      ...this._events
+    });
+
+    this._events = { __proto__: null };
+  }
+
+  resume() {
+    const events = wm.get(this);
+    if (events) {
+      this._events = {
+        __proto__: null,
+        ...events
+      };
+      wm.set(this, null);
+    }
+  }
+}
+
+module.exports = Suspendable;

lib/mixins/within.js lib/mixins/withinable.js

@@ -2,7 +2,7 @@ const Board = require("./board");
 const Collection = require("./mixins/collection");
 const EVS = require("./evshield");
 const Fn = require("./fn");
-const Withinable = require("./mixins/within");
+const Suspendable = require("./mixins/suspendable");
 const Pins = Board.Pins;
 
 const toFixed = Fn.toFixed;
@@ -427,7 +427,7 @@ Controllers.DEFAULT = Controllers["GP2Y0A21YK"];
  *
  */
 
-class Proximity extends Withinable {
+class Proximity extends Suspendable {
   constructor(options) {
     super();
 

lib/proximity.js

@@ -1,7 +1,7 @@
 const Board = require("./board");
 const Collection = require("./mixins/collection");
 const Fn = require("./fn");
-const Withinable = require("./mixins/within");
+const Suspendable = require("./mixins/suspendable");
 
 // Sensor instance private data
 const priv = new Map();
@@ -28,7 +28,7 @@ function median(input) {
  * @param {Object} options Options: pin, freq, range
  */
 
-class Sensor extends Withinable {
+class Sensor extends Suspendable {
   constructor(options) {
 
     super();

lib/sensor.js

@@ -1,6 +1,6 @@
 const Board = require("./board");
 const Emitter = require("events");
-const Withinable = require("./mixins/within");
+const Suspendable = require("./mixins/suspendable");
 const {
   toFixed,
   POW_2_16,
@@ -880,7 +880,7 @@ Controllers.DEFAULT = Controllers.ANALOG;
 
 var priv = new Map();
 
-class Thermometer extends Withinable {
+class Thermometer extends Suspendable {
   constructor(options) {
     super();
 

lib/thermometer.js

@@ -90,6 +90,7 @@
     "ShiftRegisters": true,
     "Sonar": true,
     "Stepper": true,
+    "Suspendable": true,
     "Switch": true,
     "temporal": true,
     "Thermometer": true,

test/.jshintrc

@@ -7,7 +7,8 @@ global.Emitter = require("events");
 
 // Internal
 global.Collection = require("../../lib/mixins/collection");
-global.Withinable = require("../../lib/mixins/within");
+global.Suspendable = require("../../lib/mixins/suspendable");
+global.Withinable = require("../../lib/mixins/withinable");
 global.five = require("../../lib/johnny-five");
 global.EVS = require("../../lib/evshield");
 

test/common/bootstrap.js

@@ -1171,7 +1171,7 @@ exports["Sensor - Analog"] = {
     this.clock.tick(25);
 
     test.done();
-  }, // ./within: function(test)
+  }, // ./withinable: function(test)
 
   booleanAt(test) {
     const callback = this.analogRead.args[0][1];

test/sensor.js

@@ -0,0 +1,162 @@
+require("./common/bootstrap");
+
+const Crypto = require("crypto");
+
+class Component extends Suspendable {
+  constructor(options) {
+    super();
+
+    var value = null;
+
+    this.board = options.board;
+    this.io = options.board.io;
+    this.pin = options.pin;
+
+    this.io.analogRead(this.pin, (data) => {
+      value = data;
+      this.emit("data", value);
+    });
+
+
+    this.tracking = {
+      value: {
+        get: 0,
+        set: 0,
+      },
+      unit: {
+        get: 0,
+      },
+    };
+
+    Object.defineProperties(this, {
+      value: {
+        get: function() {
+          this.tracking.value.get++;
+          return value;
+        },
+        set: function(input) {
+          this.tracking.value.set++;
+          value = input;
+        },
+      },
+      unit: {
+        get: function() {
+          this.tracking.unit.get++;
+          return value;
+        },
+      },
+    });
+  }
+}
+
+exports["Suspendable"] = {
+  setUp(done) {
+    this.sandbox = sinon.sandbox.create();
+    this.board = newBoard();
+    this.analogRead = this.sandbox.spy(MockFirmata.prototype, "analogRead");
+    this.component = new Component({
+      board: this.board,
+      pin: "A0",
+    });
+
+    done();
+  },
+  tearDown(done) {
+    Board.purge();
+    this.sandbox.restore();
+    done();
+  },
+
+  isInstanceOf(test) {
+    test.expect(3);
+    test.equal(new Suspendable() instanceof Withinable, true);
+    test.equal(this.component instanceof Suspendable, true);
+    test.equal(this.component instanceof Withinable, true);
+    test.done();
+  },
+
+  pauseIsAFunction(test) {
+    test.expect(1);
+    const suspendable = new Suspendable();
+    test.equal(typeof suspendable.pause, "function");
+    test.done();
+  },
+
+  resumeIsAFunction(test) {
+    test.expect(1);
+    const suspendable = new Suspendable();
+    test.equal(typeof suspendable.resume, "function");
+    test.done();
+  },
+
+  suspendability(test) {
+    test.expect(5);
+    const suspendable = new Suspendable();
+    const expectedBytes = [];
+    const emittedBytes = [];
+
+    suspendable.on("data", byte => emittedBytes.push(byte));
+
+    let turns = 0;
+    let interval = setInterval(() => {
+      const byte = Crypto.randomBytes(1);
+      turns++;
+      suspendable.emit("data", byte);
+
+      if (turns === 2) {
+        suspendable.pause();
+      }
+
+      if (turns === 4) {
+        suspendable.resume();
+      }
+
+      if (turns <= 2 || turns > 4) {
+        expectedBytes.push(byte);
+      }
+
+      if (turns === 6) {
+        test.equal(emittedBytes.length, 4);
+        emittedBytes.forEach((b, index) => test.equal(b, expectedBytes[index]));
+        clearInterval(interval);
+        test.done();
+      }
+    }, 5);
+  },
+
+  componentSuspendability(test) {
+    test.expect(5);
+    const analogRead = this.analogRead.lastCall.args[1];
+    const expectedBytes = [];
+    const emittedBytes = [];
+
+    this.component.on("data", byte => emittedBytes.push(byte));
+
+    let turns = 0;
+    let interval = setInterval(() => {
+      const byte = Crypto.randomBytes(1);
+      turns++;
+      analogRead(byte);
+
+      if (turns === 2) {
+        this.component.pause();
+      }
+
+      if (turns === 4) {
+        this.component.resume();
+      }
+
+      if (turns <= 2 || turns > 4) {
+        expectedBytes.push(byte);
+      }
+
+      if (turns === 6) {
+        test.equal(emittedBytes.length, 4);
+        emittedBytes.forEach((b, index) => test.equal(b, expectedBytes[index]));
+        clearInterval(interval);
+        test.done();
+      }
+    }, 5);
+  },
+
+};