Singletonable mixin

CHANGES

@@ -1,3 +1,4 @@
+1.0.7 - Add singletonable mixin (also added to BaseObject)
 1.0.6 - Add soakCall corresponding to soakApply
 1.0.5 - Add soakApply and allow soak strings to be passed as function builder arguments
 1.0.4 - Add applyMethod to underscore

lib/baseObject.js

@@ -13,6 +13,7 @@
 require('./objectUnderscore');
 var superExtendable = require('./superExtendable');
 var gettable = require('./gettable');
+var singletonable = require('./singletonable');
 
 // Check that the constructor was called with `new`
 function badConstructorCall(obj) {
@@ -74,6 +75,7 @@ BaseObject.addProperties = function (varArgs) {
 
 superExtendable(BaseObject);
 gettable(BaseObject);
+singletonable(BaseObject);
 
 var originalExtend = BaseObject.extend;
 

lib/singletonable.js

@@ -0,0 +1,25 @@
+// Add lazy singletons to Constructors. This adds a makeSingleton class
+// method, which will create a singleton property of the given name, passing
+// the remaining arguments to the constructor.
+//
+// The singleton is constructed on first access, through
+// Object.defineProperty. This defers initialization, simplifying dependency
+// management.
+
+module.exports = function (Constructor) {
+  Constructor.makeSingleton = function (name, varargs) {
+    // Singleton should be of whatever makeSingleton was called on, not
+    // necessarily what was passed to singletonable()
+    var Child = this;
+    varargs = arguments._.tail();
+
+    // Storage for the the singleton object, once it is created
+    var singleton;
+    Object.defineProperty(Child, name, {
+      get: function () {
+        if (!singleton) singleton = _.applyConstructor(Child, varargs)
+        return singleton;
+      },
+    })
+  }
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "intrusive",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "a set of intrusive javascript modules, not for use in libraries",
   "main": "index.js",
   "scripts": {

test/baseObject.js

@@ -20,4 +20,81 @@ describe('Base object', function () {
       }).to.throw;
     })
   })
+
+  describe('when you create a singleton', function () {
+    var S = BaseObject.extend({
+      x: 1,
+      y: 2,
+    });
+    S.makeSingleton('first');
+    S.makeSingleton('second');
+
+    it('should have created the first singleton', function () {
+      return expect(S.first.x).equal(1)
+    })
+
+    it('should have created the second singleton', function () {
+      return expect(S.second.x).equal(1)
+    })
+
+    describe('when you modify a property on one singleton', function () {
+      before(function () {
+        S.first.x = 2;
+      })
+
+      it('should modify the first singleton', function () {
+        return expect(S.first.x).equal(2);
+      })
+
+      it('should not modify the second singleton', function () {
+        return expect(S.second.x).equal(1);
+      })
+    })
+
+    describe('when you have a subclass', function () {
+      var T;
+      before(function () {
+        T = S.extend({
+          y: 3,
+          z: 4,
+        })
+      })
+
+      describe('when you make a new singleton', function () {
+        before(function () {
+          T.makeSingleton('third');
+        })
+
+        it('should not create the singleton on the parent constructor', function () {
+          return expect(S.third).undefined;
+        })
+
+        it('should create a singleton on the child constructor', function () {
+          return expect(T.third).not.undefined;
+        })
+
+        it('should create a singleton that is an instance of the child constructor', function () {
+          return expect(T.third.z).equal(4);
+        })
+      })
+
+      describe('when you override a singleton', function () {
+        before(function () {
+          T.makeSingleton('first');
+        })
+
+        it('should not change parent constructor singleton', function () {
+          return expect(S.first.y).equal(2);
+        })
+
+        it('should create a singleton on the child constructor', function () {
+          return expect(T.first).not.undefined;
+        })
+
+        it('should create a singleton that is an instance of the child constructor', function () {
+          return expect(T.first.z).equal(4);
+        })
+      })
+    })
+  })
 })

test/singletonable.js

@@ -0,0 +1,44 @@
+var init = require('./init');
+var singletonable = require('../lib/singletonable');
+
+describe('Singletonable', function () {
+  var constructorCalls = 0;
+  var Klass = function (a, b, c) {
+    var self = this;
+    constructorCalls++;
+    self.a = a;
+    self.b = b;
+    self.c = c;
+  }
+
+  singletonable(Klass);
+
+  describe('when you create a singleton', function () {
+    before(function () {
+      Klass.makeSingleton('singleton', 1, 2, 3);
+    })
+
+    it('should not call the constructor', function () {
+      return expect(constructorCalls).equal(0);
+    })
+
+    it('should have a property for the singleton', function () {
+      return expect(Klass.hasOwnProperty('singleton')).true;
+    })
+
+    describe('when you access the constructor', function () {
+      before(function () {
+        Klass.singleton;
+        Klass.singleton;
+      })
+
+      it('should have called the constructor once', function () {
+        return expect(constructorCalls).equal(1);
+      })
+
+      it('should have the correct properties', function () {
+        return expect(Klass.singleton._.pick('a', 'b', 'c')).deep.equal({a: 1, b: 2, c: 3});
+      })
+    })
+  })
+})