hippodrome 0.0.10 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 19da9bf256e5d40f3005adf676963347314bd33c
-  data.tar.gz: 344fd5939a332b0cd1fa5b29f9cdd3424a5a97a6
+  metadata.gz: 2cade2f33b8f261faf01d57453b3776b6603c2e4
+  data.tar.gz: ace2d0166e2fa55b203d098c472a4bbfd91c385f
 SHA512:
-  metadata.gz: 95dd1cc9a3c526b50170cc3510ad8dde0115d5402f297615ba8bb02132b04b94bc82d586554a0488b87ddea4c4924567cd7a502f205313447cd17de4added528
-  data.tar.gz: 6b755e68ec71c6c342694eb24c593d4bb0ad6134be658166be5c1eaa56748ef471bbbac7c96853ce0f44efb3241df820d18c667dee6832a2e02e87fa8e7f254f
+  metadata.gz: 49a39346480f430a5ca599a90a2febb65a46ebc7aaac0b4930afdcc4e001b397a088f839a7634d22bd3cd956cdf6fabb304ae4c7d7372d221debf0ebc15379d1
+  data.tar.gz: 6903cf94ec164280f96eef6e47e9db56c4d9c3a73c320fab61da1c7ad777e8e563da442e74378c8a74354a563a62a4be7101ad692cf2025bf77cc3a0fc7bd74e

data/README.md

@@ -20,6 +20,8 @@ response.
 
 ## Installation
 
+### Rails
+
 Add this line to your application's Gemfile:
 
     gem 'hippodrome'
@@ -32,12 +34,23 @@ Or install it yourself as:
 
     $ gem install hippodrome
 
+### Node
+
+    npm install --save hippodrome
+
 ## Usage
 
+### Rails
+
 In your javascript manifest file:
 
     //= require hippodrome
 
+### Node
+
+    Hippodrome = require('hippodrome')
+
+
 TODO: Explain how all the bits work.
 
 ## Contributing

data/app/assets/javascripts/hippodrome.js

@@ -0,0 +1,245 @@
+//= require lodash
+
+(function() {
+  var Action, Dispatcher, Hippodrome, SideEffect, Store, assert, bindToContextIfFunction, isNode, lastId, nextId, prefix, _,
+    __slice = [].slice;
+
+  isNode = typeof window === 'undefined';
+
+  if (isNode) {
+    _ = require('lodash');
+  } else {
+    _ = this._;
+  }
+
+  Hippodrome = {};
+
+  assert = function() {
+    var argIndex, args, condition, error, message;
+    condition = arguments[0], message = arguments[1], args = 3 <= arguments.length ? __slice.call(arguments, 2) : [];
+    if (!condition) {
+      argIndex = 0;
+      error = new Error('Assertion Failed: ' + message.replace(/%s/g, function() {
+        return args[argIndex++];
+      }));
+      error.framesToPop = 1;
+      throw error;
+    }
+    return condition;
+  };
+
+  Action = function(name, ctor) {
+    var actionFn, buildPayload, send;
+    buildPayload = function() {
+      var payload;
+      payload = ctor.apply(null, arguments);
+      payload.action = name;
+      return payload;
+    };
+    send = function(payload) {
+      return Hippodrome.Dispatcher.dispatch(payload);
+    };
+    actionFn = function() {
+      var payload;
+      payload = buildPayload.apply(null, arguments);
+      return send(payload);
+    };
+    actionFn.buildPayload = buildPayload;
+    actionFn.send = send;
+    actionFn.hippoName = name;
+    actionFn.toString = function() {
+      return name;
+    };
+    return actionFn;
+  };
+
+  Hippodrome.Action = Action;
+
+  Dispatcher = function() {
+    this.callbacksByAction = {};
+    this.isStarted = {};
+    this.isFinished = {};
+    this.isDispatching = false;
+    return this.payload = null;
+  };
+
+  prefix = 'Dispatcher_ID_';
+
+  lastId = 1;
+
+  nextId = function() {
+    return prefix + lastId++;
+  };
+
+  Dispatcher.prototype.register = function() {
+    var action, args, callback, id, prereqStores, store, _base;
+    args = _.compact(arguments);
+    if (args.length === 3) {
+      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) {
+        _base[action] = {};
+      }
+      id = nextId();
+      this.callbacksByAction[action][id] = {
+        callback: callback,
+        prerequisites: _.map(prereqStores, function(ps) {
+          return ps.dispatcherIdsByAction[action];
+        })
+      };
+      return id;
+    }
+  };
+
+  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;
+  };
+
+  Dispatcher.prototype.waitFor = function(action, ids) {
+    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);
+          return;
+        }
+        assert(_this.callbacksByAction[action][id], 'Dispatcher.waitFor `%s` is not a registered callback for %s.', id, action);
+        return _this.invokeCallback(action, id);
+      };
+    })(this));
+  };
+
+  Dispatcher.prototype.dispatch = function(payload) {
+    var action;
+    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 function(callback, id) {
+          if (_this.isStarted[id]) {
+            return;
+          }
+          return _this.invokeCallback(action, id);
+        };
+      })(this));
+    } finally {
+      this.stopDispatching();
+    }
+  };
+
+  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.waitFor(action, prerequisites);
+    callback(this.payload);
+    return this.isFinished[id] = true;
+  };
+
+  Dispatcher.prototype.startDispatching = function(payload) {
+    this.isStarted = {};
+    this.isFinished = {};
+    this.payload = payload;
+    return this.isDispatching = true;
+  };
+
+  Dispatcher.prototype.stopDispatching = function() {
+    this.payload = null;
+    return this.isDispatching = false;
+  };
+
+  Hippodrome.Dispatcher = new Dispatcher();
+
+  SideEffect = function(options) {
+    var action, effect, id;
+    assert(options.action, 'SideEffect must register for exactly one action.');
+    assert(options.effect, 'SideEffect must supply exactly one effect to run');
+    action = options.action, effect = options.effect;
+    if (typeof effect === 'string') {
+      effect = this[effect];
+    }
+    effect = _.defer.bind(this, effect);
+    id = Hippodrome.Dispatcher.register(this, action.hippoName, [], effect);
+    this.dispatcherIdsByAction = {};
+    this.dispatcherIdsByAction[action.hippoName] = id;
+    return this;
+  };
+
+  Hippodrome.SideEffect = SideEffect;
+
+  bindToContextIfFunction = function(context) {
+    return function(objValue, srcValue) {
+      if (srcValue instanceof Function) {
+        return srcValue.bind(context);
+      } else {
+        return srcValue;
+      }
+    };
+  };
+
+  Store = function(options) {
+    this.dispatcherIdsByAction = {};
+    this.callbacks = [];
+    _.assign(this, _.omit(options, 'initialize', 'dispatches'), bindToContextIfFunction(this));
+    if (options.initialize) {
+      options.initialize.call(this);
+    }
+    if (options.dispatches) {
+      _.forEach(options.dispatches, (function(_this) {
+        return function(callbackDescription) {
+          var action, after, callback, id;
+          action = callbackDescription.action, after = callbackDescription.after, callback = callbackDescription.callback;
+          assert(!_this.dispatcherIdsByAction[action.hippoName], 'Each store can only register one callback for each action.');
+          if (typeof callback === 'string') {
+            callback = _this[callback];
+          }
+          callback = callback.bind(_this);
+          id = Hippodrome.Dispatcher.register(_this, action.hippoName, after, callback);
+          return _this.dispatcherIdsByAction[action.hippoName] = id;
+        };
+      })(this));
+    }
+    return this;
+  };
+
+  Store.prototype.register = function(callback) {
+    return this.callbacks.push(callback);
+  };
+
+  Store.prototype.unregister = function(callback) {
+    return this.callbacks = _.reject(this.callbacks, function(cb) {
+      return cb === callback;
+    });
+  };
+
+  Store.prototype.listen = function(callbackName) {
+    var store;
+    store = this;
+    return {
+      componentDidMount: function() {
+        return store.register(this[callbackName]);
+      },
+      componentWillUnmount: function() {
+        return store.unregister(this[callbackName]);
+      }
+    };
+  };
+
+  Store.prototype.trigger = function() {
+    return _.forEach(this.callbacks, function(callback) {
+      return callback();
+    });
+  };
+
+  Hippodrome.Store = Store;
+
+  if (isNode) {
+    module.exports = Hippodrome;
+  } else {
+    this.Hippodrome = Hippodrome;
+  }
+
+}).call(this);

data/lib/hippodrome/version.rb

@@ -1,3 +1,5 @@
+require 'json'
+
 module Hippodrome
-  VERSION = "0.0.10"
+  VERSION = JSON.load(File.open('package.json', 'r'))['version']
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hippodrome
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.16
 platform: ruby
 authors:
 - Sean Kermes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-12 00:00:00.000000000 Z
+date: 2014-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,20 +53,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '4.0'
-- !ruby/object:Gem::Dependency
-  name: coffee-rails
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 4.0.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 4.0.1
 - !ruby/object:Gem::Dependency
   name: lodash-rails
   requirement: !ruby/object:Gem::Requirement
@@ -94,12 +80,7 @@ extra_rdoc_files: []
 files:
 - LICENSE.txt
 - README.md
-- app/assets/javascripts/action.js.coffee
-- app/assets/javascripts/assert.js.coffee
-- app/assets/javascripts/dispatcher.js.coffee
-- app/assets/javascripts/hippodrome.js.coffee
-- app/assets/javascripts/side_effect.js.coffee
-- app/assets/javascripts/store.js.coffee
+- app/assets/javascripts/hippodrome.js
 - lib/hippodrome.rb
 - lib/hippodrome/version.rb
 homepage: https://github.com/Structural/hippodrome

data/app/assets/javascripts/action.js.coffee

@@ -1,22 +0,0 @@
-Action = (name, ctor) ->
-  buildPayload = ->
-    payload = ctor.apply(null, arguments)
-    payload.action = name
-    payload
-
-  send = (payload) ->
-    Hippodrome.Dispatcher.dispatch(payload)
-
-  actionFn = ->
-    payload = buildPayload.apply(null, arguments)
-    send(payload)
-
-  actionFn.buildPayload = buildPayload
-  actionFn.send = send
-
-  actionFn.hippoName = name
-  actionFn.toString = -> name
-
-  actionFn
-
-Hippodrome.Action = Action

data/app/assets/javascripts/assert.js.coffee

@@ -1,12 +0,0 @@
-Hippodrome.assert = (condition, message, args...) ->
-  if not condition
-    # TODO: Don't report in non-dev mode
-    argIndex = 0;
-    error = new Error('Assertion Failed: ' +
-                      message.replace(/%s/g, -> args[argIndex++]))
-
-    # Ignore assert's frame
-    error.framesToPop = 1
-    throw error
-
-  condition

data/app/assets/javascripts/dispatcher.js.coffee

@@ -1,83 +0,0 @@
-Dispatcher = ->
-  @callbacksByAction = {}
-  @isStarted = {}
-  @isFinished = {}
-  @isDispatching = false
-  @payload = null
-
-prefix = 'Dispatcher_ID_'
-lastId = 1
-nextId = -> prefix + lastId++
-
-Dispatcher.prototype.register = ->
-  args = _.compact(arguments)
-
-  if args.length == 3
-    @register(args[0], args[1], [], args[2])
-  else
-    [store, action, prereqStores, callback] = args
-    @callbacksByAction[action] ?= {}
-
-    id = nextId()
-    @callbacksByAction[action][id] = {
-      callback: callback,
-      prerequisites: _.map(prereqStores,
-                           (ps) -> ps.dispatcherIdsByAction[action])
-    }
-    id
-
-Dispatcher.prototype.unregister = (action, id) ->
-  Hippodrome.assert(@callbacksByAction[action][id],
-         'Dispatcher.unregister(%s, %s) does not map to a registered callback.',
-         action, id)
-  @callbacks[action][id] = null
-
-Dispatcher.prototype.waitFor = (action, ids) ->
-  Hippodrome.assert(@isDispatching,
-         'Dispatcher.waitFor must be invoked while dispatching.')
-  _.forEach(ids, (id) =>
-    if @isStarted[id]
-      Hippodrome.assert(@isFinished[id],
-             'Dispatcher.waitFor encountered circular dependency while ' +
-             'waiting for `%s` during %s.', id, action)
-      return
-
-    Hippodrome.assert(@callbacksByAction[action][id],
-           'Dispatcher.waitFor `%s` is not a registered callback for %s.',
-           id, action)
-    @invokeCallback(action, id)
-  )
-
-Dispatcher.prototype.dispatch = (payload) ->
-  Hippodrome.assert(not @isDispatching,
-         'Dispatch.dispatch cannot be called during dispatch.')
-  @startDispatching(payload)
-  try
-    action = payload.action
-    _.forEach(@callbacksByAction[action], (callback, id) =>
-      if @isStarted[id]
-        return
-
-      @invokeCallback(action, id)
-    )
-  finally
-    @stopDispatching()
-
-Dispatcher.prototype.invokeCallback = (action, id) ->
-  @isStarted[id] = true
-  {callback, prerequisites} = @callbacksByAction[action][id]
-  @waitFor(action, prerequisites)
-  callback(@payload)
-  @isFinished[id] = true
-
-Dispatcher.prototype.startDispatching = (payload) ->
-  @isStarted = {}
-  @isFinished = {}
-  @payload = payload
-  @isDispatching = true
-
-Dispatcher.prototype.stopDispatching = ->
-  @payload = null
-  @isDispatching = false
-
-Hippodrome.Dispatcher = new Dispatcher()

data/app/assets/javascripts/hippodrome.js.coffee

@@ -1,5 +0,0 @@
-#= require lodash
-#= require_self
-#= require_tree .
-
-window.Hippodrome = {}

data/app/assets/javascripts/side_effect.js.coffee

@@ -1,19 +0,0 @@
-SideEffect = (options) ->
-  Hippodrome.assert(options.action,
-         'SideEffect must register for exactly one action.')
-  Hippodrome.assert(options.effect,
-         'SideEffect must supply exactly one effect to run')
-
-  {action, effect} = options
-
-  if typeof effect == 'string'
-    effect = this[effect]
-  effect = _.defer.bind(this, effect)
-
-  id = Hippodrome.Dispatcher.register(this, action.hippoName, [], effect)
-  @dispatcherIdsByAction = {}
-  @dispatcherIdsByAction[action.hippoName] = id
-
-  this
-
-Hippodrome.SideEffect = SideEffect

data/app/assets/javascripts/store.js.coffee

@@ -1,52 +0,0 @@
-bindToContextIfFunction = (context) ->
-  (objValue, srcValue) ->
-    if srcValue instanceof Function
-      srcValue.bind(context)
-    else
-      srcValue
-
-Store = (options) ->
-  @dispatcherIdsByAction = {}
-  @callbacks = []
-  _.assign(this, _.omit(options, 'initialize', 'dispatches'), bindToContextIfFunction(this))
-
-  if options.initialize
-    options.initialize.call(@)
-
-  if options.dispatches
-    _.forEach(options.dispatches, (callbackDescription) =>
-      {action, after, callback} = callbackDescription
-
-      Hippodrome.assert(not @dispatcherIdsByAction[action.hippoName]
-             'Each store can only register one callback for each action.')
-
-      if typeof callback == 'string'
-        callback = @[callback]
-      callback = callback.bind(@)
-
-      id = Hippodrome.Dispatcher.register(this, action.hippoName, after, callback)
-      @dispatcherIdsByAction[action.hippoName] = id
-    )
-
-  this
-
-Store.prototype.register = (callback) ->
-  @callbacks.push(callback)
-
-Store.prototype.unregister = (callback) ->
-  @callbacks = _.reject(@callbacks, (cb) -> cb == callback)
-
-# register/unregister are completely general, this is tailored for React mixins.
-Store.prototype.listen = (callbackName) ->
-  store = this
-  return {
-    componentDidMount: ->
-      store.register(this[callbackName])
-    componentWillUnmount: ->
-      store.unregister(this[callbackName])
-  }
-
-Store.prototype.trigger = ->
-  _.forEach(@callbacks, (callback) -> callback())
-
-Hippodrome.Store = Store