hippodrome 0.0.18 → 0.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b5036e5c66a8704fd400c621f9c369e0ed3d4d4
-  data.tar.gz: e5c3b2aabd0e7b4adefce19d8c1c8d84032e7393
+  metadata.gz: 2c68318dc3daa63974b6da46be215c8cb0deb986
+  data.tar.gz: faa05a1abd41d279f1dfce251c96c70a5808236d
 SHA512:
-  metadata.gz: 45584434b782e936b87a02eaa2666d153a428afc9c578b087770f72055fa3e55635a426e3416eeabf53d5b7cfa3768c03dea8b097d624985e61e6881ee5cbeaf
-  data.tar.gz: 38ae906af22d94d0a11311c297cfc051e4ed8b1d39e9bd38834c92a922f0ca40ae52f14e6de49859c45e539ebfedf8fda509ba452ffca6aea2e5658cfff7207d
+  metadata.gz: 3e24c6a346401db5a0107e224f14246497962327bb12160ad7ae048dda8e0379ba9ac37db551021359663488f6f7c1d40a9f88310efe894f8d3afc903c6f5030
+  data.tar.gz: fc0d6bb27e559e9321e6c57e26cae414b1321c8201a9bcf910894f20bb45ba0fabeb3649251d3f95945e7a7ccc14a1e484a54d4e6fccf37d7224ed014af46822

data/app/assets/javascripts/hippodrome.js

@@ -1,7 +1,7 @@
 //= require lodash
 
 (function() {
-  var Action, DeferredTask, Dispatcher, Hippodrome, Store, assert, bindToContextIfFunction, isNode, lastId, nextId, prefix, _,
+  var Action, DeferredTask, Dispatcher, Hippodrome, IdFactory, Store, actionIds, assert, bindToContextIfFunction, dispatcherIds, isNode, _,
     __slice = [].slice;
 
   isNode = typeof window === 'undefined';
@@ -28,12 +28,24 @@
     return condition;
   };
 
+  IdFactory = function(prefix) {
+    this._lastId = 1;
+    return this._prefix = prefix;
+  };
+
+  IdFactory.prototype.next = function() {
+    return "" + this._prefix + "_" + (this._lastId++);
+  };
+
+  actionIds = new IdFactory('Action_ID');
+
   Action = function(name, ctor) {
-    var actionFn, buildPayload, send;
+    var actionFn, buildPayload, id, send;
+    id = "" + (actionIds.next()) + "_" + name;
     buildPayload = function() {
       var payload;
       payload = ctor.apply(null, arguments);
-      payload.action = name;
+      payload.action = id;
       return payload;
     };
     send = function(payload) {
@@ -46,9 +58,10 @@
     };
     actionFn.buildPayload = buildPayload;
     actionFn.send = send;
-    actionFn.hippoName = name;
+    actionFn.displayName = name;
+    actionFn.id = id;
     actionFn.toString = function() {
-      return name;
+      return id;
     };
     return actionFn;
   };
@@ -56,20 +69,14 @@
   Hippodrome.Action = Action;
 
   Dispatcher = function() {
-    this.callbacksByAction = {};
-    this.isStarted = {};
-    this.isFinished = {};
-    this.isDispatching = false;
-    return this.payload = null;
+    this._callbacksByAction = {};
+    this._isStarted = {};
+    this._isFinished = {};
+    this._isDispatching = false;
+    return this._payload = null;
   };
 
-  prefix = 'Dispatcher_ID_';
-
-  lastId = 1;
-
-  nextId = function() {
-    return prefix + lastId++;
-  };
+  dispatcherIds = new IdFactory('Dispatcher_ID');
 
   Dispatcher.prototype.register = function() {
     var action, args, callback, id, prereqStores, store, _base;
@@ -78,14 +85,14 @@
       return this.register(args[0], args[1], [], args[2]);
     } else {
       store = args[0], action = args[1], prereqStores = args[2], callback = args[3];
-      if ((_base = this.callbacksByAction)[action] == null) {
+      if ((_base = this._callbacksByAction)[action] == null) {
         _base[action] = {};
       }
-      id = nextId();
-      this.callbacksByAction[action][id] = {
+      id = dispatcherIds.next();
+      this._callbacksByAction[action][id] = {
         callback: callback,
         prerequisites: _.map(prereqStores, function(ps) {
-          return ps.storeImpl.dispatcherIdsByAction[action];
+          return ps._storeImpl.dispatcherIdsByAction[action];
         })
       };
       return id;
@@ -93,19 +100,19 @@
   };
 
   Dispatcher.prototype.unregister = function(action, id) {
-    assert(this.callbacksByAction[action][id], 'Dispatcher.unregister(%s, %s) does not map to a registered callback.', action, id);
-    return this.callbacks[action][id] = null;
+    assert(this._callbacksByAction[action][id], 'Dispatcher.unregister(%s, %s) does not map to a registered callback.', action.displayName, id);
+    return this._callbacksByAction[action][id] = null;
   };
 
   Dispatcher.prototype.waitFor = function(action, ids) {
-    assert(this.isDispatching, 'Dispatcher.waitFor must be invoked while dispatching.');
+    assert(this._isDispatching, 'Dispatcher.waitFor must be invoked while dispatching.');
     return _.forEach(ids, (function(_this) {
       return function(id) {
-        if (_this.isStarted[id]) {
-          assert(_this.isFinished[id], 'Dispatcher.waitFor encountered circular dependency while ' + 'waiting for `%s` during %s.', id, action);
+        if (_this._isStarted[id]) {
+          assert(_this._isFinished[id], 'Dispatcher.waitFor encountered circular dependency while ' + 'waiting for `%s` during %s.', id, action.displayName);
           return;
         }
-        assert(_this.callbacksByAction[action][id], 'Dispatcher.waitFor `%s` is not a registered callback for %s.', id, action);
+        assert(_this._callbacksByAction[action][id], 'Dispatcher.waitFor `%s` is not a registered callback for %s.', id, action.displayName);
         return _this.invokeCallback(action, id);
       };
     })(this));
@@ -113,13 +120,13 @@
 
   Dispatcher.prototype.dispatch = function(payload) {
     var action;
-    assert(!this.isDispatching, 'Dispatch.dispatch cannot be called during dispatch.');
+    assert(!this._isDispatching, 'Dispatch.dispatch cannot be called during dispatch.');
     this.startDispatching(payload);
     try {
       action = payload.action;
-      return _.forEach(this.callbacksByAction[action], (function(_this) {
+      return _.forEach(this._callbacksByAction[action], (function(_this) {
         return function(callback, id) {
-          if (_this.isStarted[id]) {
+          if (_this._isStarted[id]) {
             return;
           }
           return _this.invokeCallback(action, id);
@@ -132,23 +139,23 @@
 
   Dispatcher.prototype.invokeCallback = function(action, id) {
     var callback, prerequisites, _ref;
-    this.isStarted[id] = true;
-    _ref = this.callbacksByAction[action][id], callback = _ref.callback, prerequisites = _ref.prerequisites;
+    this._isStarted[id] = true;
+    _ref = this._callbacksByAction[action][id], callback = _ref.callback, prerequisites = _ref.prerequisites;
     this.waitFor(action, prerequisites);
-    callback(this.payload);
-    return this.isFinished[id] = true;
+    callback(this._payload);
+    return this._isFinished[id] = true;
   };
 
   Dispatcher.prototype.startDispatching = function(payload) {
-    this.isStarted = {};
-    this.isFinished = {};
-    this.payload = payload;
-    return this.isDispatching = true;
+    this._isStarted = {};
+    this._isFinished = {};
+    this._payload = payload;
+    return this._isDispatching = true;
   };
 
   Dispatcher.prototype.stopDispatching = function() {
-    this.payload = null;
-    return this.isDispatching = false;
+    this._payload = null;
+    return this._isDispatching = false;
   };
 
   Hippodrome.Dispatcher = new Dispatcher();
@@ -162,9 +169,9 @@
       task = this[task];
     }
     task = _.defer.bind(this, task);
-    id = Hippodrome.Dispatcher.register(this, action.hippoName, [], task);
-    this.dispatcherIdsByAction = {};
-    this.dispatcherIdsByAction[action.hippoName] = id;
+    id = Hippodrome.Dispatcher.register(this, action.id, [], task);
+    this._dispatcherIdsByAction = {};
+    this._dispatcherIdsByAction[action.id] = id;
     return this;
   };
 
@@ -181,28 +188,29 @@
   };
 
   Store = function(options) {
-    this.storeImpl = {};
-    this.storeImpl.dispatcherIdsByAction = {};
-    this.storeImpl.callbacks = [];
-    _.assign(this.storeImpl, _.omit(options, 'initialize', 'dispatches', 'public'), bindToContextIfFunction(this.storeImpl));
+    this._storeImpl = {};
+    this._storeImpl.dispatcherIdsByAction = {};
+    this._storeImpl.callbacks = [];
+    _.assign(this._storeImpl, _.omit(options, 'initialize', 'dispatches', 'public'), bindToContextIfFunction(this._storeImpl));
     if (options["public"]) {
-      _.assign(this, options["public"], bindToContextIfFunction(this.storeImpl));
+      _.assign(this, options["public"], bindToContextIfFunction(this._storeImpl));
     }
+    this.displayName = options.displayName;
     if (options.initialize) {
-      options.initialize.call(this.storeImpl);
+      options.initialize.call(this._storeImpl);
     }
     if (options.dispatches) {
       _.forEach(options.dispatches, (function(_this) {
         return function(dispatch) {
           var action, after, callback, id;
           action = dispatch.action, after = dispatch.after, callback = dispatch.callback;
-          assert(!_this.storeImpl.dispatcherIdsByAction[action.hippoName], 'Each store can only register one callback for each action.');
+          assert(!_this._storeImpl.dispatcherIdsByAction[action.id], "Store " + _this.displayName + " registered two callbacks for action " + action.displayName);
           if (typeof callback === 'string') {
-            callback = _this.storeImpl[callback];
+            callback = _this._storeImpl[callback];
           }
-          callback = callback.bind(_this.storeImpl);
-          id = Hippodrome.Dispatcher.register(_this, action.hippoName, after, callback);
-          return _this.storeImpl.dispatcherIdsByAction[action.hippoName] = id;
+          callback = callback.bind(_this._storeImpl);
+          id = Hippodrome.Dispatcher.register(_this, action.id, after, callback);
+          return _this._storeImpl.dispatcherIdsByAction[action.id] = id;
         };
       })(this));
     }
@@ -210,11 +218,11 @@
   };
 
   Store.prototype.register = function(callback) {
-    return this.storeImpl.callbacks.push(callback);
+    return this._storeImpl.callbacks.push(callback);
   };
 
   Store.prototype.unregister = function(callback) {
-    return this.storeImpl.callbacks = _.reject(this.storeImpl.callbacks, function(cb) {
+    return this._storeImpl.callbacks = _.reject(this._storeImpl.callbacks, function(cb) {
       return cb === callback;
     });
   };
@@ -233,7 +241,7 @@
   };
 
   Store.prototype.trigger = function() {
-    return _.forEach(this.storeImpl.callbacks, function(callback) {
+    return _.forEach(this._storeImpl.callbacks, function(callback) {
       return callback();
     });
   };

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hippodrome
 version: !ruby/object:Gem::Version
-  version: 0.0.18
+  version: 0.0.19
 platform: ruby
 authors:
 - Sean Kermes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-24 00:00:00.000000000 Z
+date: 2014-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler