alamid-junction - npm Package Compare versions

Comparing version 0.1.0 to 0.2.0

lib/Junction.js

@@ -56,3 +56,3 @@ "use strict";
 
-    if (signal && signal.junction === this) {
+    if (isSignal.call(this, signal)) {
         signal(value);
@@ -99,3 +99,3 @@ } else {
 
-    return (signal && signal.junction === this)? signal() : signal;
+    return (isSignal.call(this, signal))? signal() : signal;
 };
@@ -112,3 +112,3 @@
 
-    if (!signal || signal.junction !== this) {
+    if (isSignal.call(this, signal) === false) {
         signal = new this.Signal();
@@ -123,2 +123,36 @@ signal.junction = this;
 
+/**
+ * Call this function is you don't need the junction anymore.
+ *
+ * Calls dispose() on all signals that have been created by this junction
+ * and removes all references.
+ */
+Junction.prototype.dispose = function () {
+    var signals = this._signals,
+        signal,
+        key;
+
+    for (key in signals) {
+        if (signals.hasOwnProperty(key)) {
+            signal = signals[key];
+            if (isSignal.call(this, signal)) {
+                signal.dispose();
+            }
+        }
+    }
+
+    this._signals = null;
+};
+
+/**
+ * Determines if the given value is a signal and if it was created by this junction.
+ *
+ * @private
+ * @param {*} value
+ * @returns {boolean}
+ */
+function isSignal(value) { /* jshint validthis: true */
+    return Boolean(value) && value.junction === this;
+}
+
 module.exports = Junction;

package.json

 {
   "name": "alamid-junction",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Provides convenient methods for setting and retrieving multiple signals",
@@ -5,0 +5,0 @@ "main": "./lib/Junction.js",

test/Junction.test.js

 "use strict";
 
 var chai = require("chai"),
+    sinon = require("sinon"),
     Junction = require("../" + require("../package.json").main),
@@ -11,28 +12,7 @@ AlamidSignal = require("alamid-signal"),
 describe("Junction", function () {
-    var junction,
-        givenValue;
+    var junction;
 
-    function Signal() {
-        function signal(value) {
-            if (arguments.length === 1) {
-                givenValue = value;
-                return signal;
-            } else {
-                return givenValue;
-            }
-        }
-        signal.constructor = Signal;
-
-        return signal;
-    }
-
-    before(function () {
-        Junction.prototype.Signal = Signal;
-    });
     beforeEach(function () {
         junction = new Junction();
     });
-    after(function () {
-        delete Junction.prototype.Signal;
-    });
 
@@ -43,127 +23,180 @@ it("should be an instance of Junction", function () {
 
-    describe(".get() before data has been set", function () {
+    describe(".prototype", function () {
+        var givenValue;
 
-        it("should return an empty object", function () {
-            expect(junction.get()).to.be.empty;
-        });
+        function Signal() {
+            function signal(value) {
+                if (arguments.length === 1) {
+                    givenValue = value;
+                    return signal;
+                } else {
+                    return givenValue;
+                }
+            }
+            signal.constructor = Signal;
 
-    });
+            return signal;
+        }
 
-    describe(".get(key) before data has been set", function () {
+        before(function () {
+            Junction.prototype.Signal = Signal;
+        });
 
-        it("should return undefined", function () {
-            expect(junction.get("name")).to.be.undefined;
+        after(function () {
+            delete Junction.prototype.Signal;
         });
 
-    });
+        describe(".get() before data has been set", function () {
 
-    describe(".set(object)", function () {
+            it("should return an empty object", function () {
+                expect(junction.get()).to.be.empty;
+            });
 
-        it("should return this", function () {
-            expect(junction.set({ type: "Pirate" })).to.equal(junction);
         });
 
-    });
+        describe(".get(key) before data has been set", function () {
 
-    describe(".set(key, value)", function () {
+            it("should return undefined", function () {
+                expect(junction.get("name")).to.be.undefined;
+            });
 
-        it("should return this", function () {
-            expect(junction.set("hello", true)).to.equal(junction);
         });
 
-    });
+        describe(".set(object)", function () {
 
-    describe(".get() after data has been set", function () {
-        var data;
+            it("should return this", function () {
+                expect(junction.set({ type: "Pirate" })).to.equal(junction);
+            });
 
-        beforeEach(function () {
-            data = {
-                greeting: "Ahoy!",
-                age: 34,
-                attributes: {}
-            };
-            junction.set(data);
         });
 
-        it("should return all data set", function () {
-            expect(junction.get()).to.deep.equal(data);
+        describe(".set(key, value)", function () {
 
-            data.type = "Pirate";
-            data.greeting = "Arr!";
-            junction.set(data);
+            it("should return this", function () {
+                expect(junction.set("hello", true)).to.equal(junction);
+            });
 
-            expect(junction.get()).to.deep.equal(data);
         });
 
-    });
+        describe(".get() after data has been set", function () {
+            var data;
 
-    describe(".get(key) after data has been set", function () {
+            beforeEach(function () {
+                data = {
+                    greeting: "Ahoy!",
+                    age: 34,
+                    attributes: {}
+                };
+                junction.set(data);
+            });
 
-        beforeEach(function () {
-            junction.set("greeting", "Ahoy!");
-            junction.set("age", 34);
-        });
+            it("should return all data set", function () {
+                expect(junction.get()).to.deep.equal(data);
 
-        it("should return the stored value", function () {
-            expect(junction.get("greeting")).to.equal("Ahoy!");
-            expect(junction.get("age")).to.equal(34);
-        });
+                data.type = "Pirate";
+                data.greeting = "Arr!";
+                junction.set(data);
 
-        it("should still return undefined for unset keys", function () {
-            expect(junction.get("victims")).to.equal(undefined);
+                expect(junction.get()).to.deep.equal(data);
+            });
+
         });
 
-    });
+        describe(".get(key) after data has been set", function () {
 
-    describe(".signal(key)", function () {
+            beforeEach(function () {
+                junction.set("greeting", "Ahoy!");
+                junction.set("age", 34);
+            });
 
-        it("should return a signal", function () {
-            var instance = junction.signal("greeting");
+            it("should return the stored value", function () {
+                expect(junction.get("greeting")).to.equal("Ahoy!");
+                expect(junction.get("age")).to.equal(34);
+            });
 
-            expect(instance).to.be.an("function");
-            expect(instance.constructor).to.equal(Signal);
+            it("should still return undefined for unset keys", function () {
+                expect(junction.get("victims")).to.equal(undefined);
+            });
+
         });
 
-        it("should return the same signal instance multiple times", function () {
-            var instance;
+        describe(".signal(key)", function () {
 
-            instance = junction.signal("greeting");
-            expect(junction.signal("greeting")).to.equal(instance);
-        });
+            it("should return a signal", function () {
+                var instance = junction.signal("greeting");
 
-        it("should return a signal representing the value specified by key", function () {
-            var greeting = junction.signal("greeting");
+                expect(instance).to.be.an("function");
+                expect(instance.constructor).to.equal(Signal);
+            });
 
-            expect(greeting()).to.equal(undefined);
-            junction.set("greeting", "Ahoy!");
-            expect(greeting()).to.equal("Ahoy!");
-            expect(junction.get("greeting")).to.equal("Ahoy!");
-        });
+            it("should return the same signal instance multiple times", function () {
+                var instance;
 
-    });
+                instance = junction.signal("greeting");
+                expect(junction.signal("greeting")).to.equal(instance);
+            });
 
-    describe(".signal(key) with alamid-signal", function () {
+            it("should return a signal representing the value specified by key", function () {
+                var greeting = junction.signal("greeting");
 
-        before(function () {
-            Junction.prototype.Signal = AlamidSignal;
-        });
+                expect(greeting()).to.equal(undefined);
+                junction.set("greeting", "Ahoy!");
+                expect(greeting()).to.equal("Ahoy!");
+                expect(junction.get("greeting")).to.equal("Ahoy!");
+            });
 
-        after(function () {
-            Junction.prototype.Signal = Signal;
         });
 
-        it("should return the same signal instance multiple times", function () {
-            var instance;
+        describe(".signal(key) with alamid-signal", function () {
 
-            instance = junction.signal("greeting");
-            expect(junction.signal("greeting")).to.equal(instance);
+            before(function () {
+                Junction.prototype.Signal = AlamidSignal;
+            });
+
+            after(function () {
+                Junction.prototype.Signal = Signal;
+            });
+
+            it("should return the same signal instance multiple times", function () {
+                var instance;
+
+                instance = junction.signal("greeting");
+                expect(junction.signal("greeting")).to.equal(instance);
+            });
+
+            it("should return a signal representing the value specified by key", function () {
+                var greeting = junction.signal("greeting");
+
+                expect(greeting()).to.equal(undefined);
+                junction.set("greeting", "Ahoy!");
+                expect(greeting()).to.equal("Ahoy!");
+                expect(junction.get("greeting")).to.equal("Ahoy!");
+            });
+
         });
 
-        it("should return a signal representing the value specified by key", function () {
-            var greeting = junction.signal("greeting");
+        describe(".dispose()", function () {
+            var name,
+                greeting;
 
-            expect(greeting()).to.equal(undefined);
-            junction.set("greeting", "Ahoy!");
-            expect(greeting()).to.equal("Ahoy!");
-            expect(junction.get("greeting")).to.equal("Ahoy!");
+            beforeEach(function () {
+                name = junction.signal("name");
+                greeting = junction.signal("greeting");
+                name.dispose = sinon.spy();
+                greeting.dispose = sinon.spy();
+                junction.set("age", 99);
+            });
+
+            it("should call dispose() on all signals that have been created by the junction", function () {
+                junction.dispose();
+
+                expect(name.dispose).to.have.been.called;
+                expect(greeting.dispose).to.have.been.called;
+            });
+
+            it("should remove the internal signals reference", function () {
+                junction.dispose();
+                expect(junction._signals).to.equal(null);
+            });
+
         });
@@ -170,0 +203,0 @@

No alert changes

Improved metrics

Total package byte prevSize

12078

increased by22.72%

Lines of code

279

increased by23.45%

No dependency changes