rails_jskit 5.0.2 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a15f3760d8c6e81a5ac1c0ffd2344c9201881cf3
-  data.tar.gz: 38b50b8168b5e20d38023fb5686dde1c08727ffa
+  metadata.gz: 240307149b562d4e71edf1aefeafcb18dcffd2f9
+  data.tar.gz: 5db7168702b8598eed85b76d16cd4fe7d57cf781
 SHA512:
-  metadata.gz: 3d926442464ed5aad88ec72dc60396491dddc28ba3410ea5394560c996b98bec35770a99a9c39ea671f7b3ed6d846feeb1175e2a9c6c7135d73ff78369ae93ee
-  data.tar.gz: db51a062072c0768ec026976656c3e6ec30bc072442d375a59d3b1e1b9a576ad79092a007f7eae312d75fb6d71012508c9abf8d167826c982f7c7e79c873e4fe
+  metadata.gz: e2de89050713116fbaad34b612b5193b810944c758a6fb9b14664da23e251a029e5238e5a12709d2c5a005902aa43714be804eccbd215d81949a9400ebf361ff
+  data.tar.gz: 94f6f5ddf9910a6a8632bb10ae9fb93963cc6807b236258f64b62db454105ab4f04dc457d604d079a57a4cae3d520b0f8e6d6b672658f70fc99de2c91339f68e

data/README.md

@@ -107,7 +107,7 @@ Documentation
 
 ### Application Object
 
-RailsJskit will automatically create a JSkit application object for you, using the configured `app_namespace` for the global variable name _(defaults to "App")_. This global namespace provides you a way to interact with your JSkit application. You can #{link_to "configure", "#configuration"} this setting in your initializer `(config/initializers/rails_jskit.rb)`.
+RailsJskit will automatically create a JSkit application object for you, using the configured `app_namespace` for the global variable name _(defaults to "App")_. This global namespace provides you a way to interact with your JSkit application. You can [configure](#configuration) this setting in your initializer `(config/initializers/rails_jskit.rb)`.
 
 #### Dispatcher
 
@@ -472,7 +472,7 @@ Testing
 
 One of the main advantages of RailsJSkit is that it provides a simple structure that's easily tested. There are however, a few things you need to keep in mind while testing JSkit controllers.
 
-When testing, it's important to use the #{link_to "Controller Factories", "#controller-factories"} to create your test subjects. This ensures that you always have a fresh version of the controller that has not been mutated by previous tests. A basic jasmine/mocha style JSkit controller test looks something like this:
+When testing, it's important to use the [Controller Factories](#controller-factories) to create your test subjects. This ensures that you always have a fresh version of the controller that has not been mutated by previous tests. A basic jasmine/mocha style JSkit controller test looks something like this:
 
 ```js
 // spec/javscripts/controllers/posts_controller_spec.js

data/app/assets/javascripts/jskit.js

@@ -6,7 +6,6 @@
 */
 var JSkit = (function() {
   if (!_) throw new Error("JSkit: lodash or underscore is required");
-  if (!$) throw new Error("JSkit: jQuery or equivalent is required");
 
   return {
     /**
@@ -27,8 +26,8 @@ var JSkit = (function() {
  * @class Dispatcher
 */
 JSkit.Dispatcher = (function() {
-  var contains = _.contains;
-  var pluck = _.pluck;
+  var any = _.any;
+  var each = _.each;
 
   /**
     Get all handler functions for a given dispatcher and event.
@@ -69,7 +68,7 @@ JSkit.Dispatcher = (function() {
   */
   function registerHandler(registeredHandlers, eventHandler, method) {
     method = method || "push";
-    if (!contains(pluck(registeredHandlers, "handler"), eventHandler.handler)) {
+    if (!any(registeredHandlers, eventHandler)) {
       registeredHandlers[method](eventHandler);
     }
   }
@@ -146,7 +145,7 @@ JSkit.Dispatcher = (function() {
           var eventHhandlers = this.__events__[eventName] || [];
           var args = _.rest(arguments);
 
-          _.each(eventHhandlers, function(eventHandler) {
+          each(eventHhandlers, function(eventHandler) {
             var handler = eventHandler.handler;
             var context = eventHandler.context;
             handler.apply(context, args);
@@ -157,301 +156,228 @@ JSkit.Dispatcher = (function() {
   };
 })();
 
-/**
- * @module JSkit
- * @class Controller
-*/
 JSkit.Controller = (function() {
+  var bind = _.bind;
   var bindAll = _.bindAll;
+  var cloneDeep = _.cloneDeep;
   var compact = _.compact;
   var defaults = _.defaults;
   var each = _.each;
+  var extend = _.extend;
   var first = _.first;
   var flatten = _.flatten;
-  var functions = _.functions;
-  var isFunc = _.isFunction;
+  var includes = _.includes;
+  var isArray = _.isArray;
+  var isFunction = _.isFunction;
   var isObject = _.isObject;
   var keys = _.keys;
   var last = _.last;
   var map = _.map;
-  var pairs = _.pairs;
   var reduce = _.reduce;
-  var uniq = _.uniq;
-  var values = _.values;
+  var underscore = _.snakeCase;
+
+  function restrictKeywords(attrs) {
+    var keywords = [
+      "registerEvents",
+      "registerActions",
+      "cacheElements",
+      "eventNameForAction"
+    ];
+
+    each(keys(attrs), function(keyword) {
+      if (includes(keywords, keyword)) {
+        throw new Error("JSkit.Controller.create: " + keyword + " is a restricted keyword");
+      }
+    });
+  }
 
-  /**
-   * Take a string and put underscores between names and delimiters
-   *
-   * @private
-   * @method constantize
-   * @param {String} string
-   * @return {String}
-  */
-  function underscore(string) {
-    string = string || "";
-    return string.replace(/([A-Z])/g, " $1").replace(/^\s?/, "").replace(/-|\s/g, "_").toLowerCase();
+  function eventNameForAction(controller, action) {
+    return compact([
+      controller.namespace,
+      controller.channel,
+      controller.controllerEventName,
+      action
+    ]).join(controller.eventSeparator);
   }
 
-  /**
-   * Register the controller's actions to the dispatcher
-   *
-   * @private
-   * @method registerActions
-   * @param {Controller} controller
-  */
-  function registerActions(controller) {
-    each(controller.actions, function(action) {
-      each(mapAction(action), function(actionMap) {
-        ensureActionIsDefined(controller, actionMap);
-        controller.dispatcher.on(actionEventName(controller, actionMap.name), controller[actionMap.method], controller);
-      }, controller);
-    }, controller);
+  function registerAllAction(controller) {
+    if (!includes(controller.actions, "all")) controller.actions.unshift("all");
   }
 
-  /**
-   * Take an action string or mapped action and return
-   * an object containing the action name and method.
-   *
-   * @private
-   * @method mapAction
-   * @param {String,Object} action/mappedAction
-   * @return {Array} action/event maps
-  */
-  function mapAction(action) {
-    return isObject(action) ? map(action, createActionMap) : [createActionMap(action, action)];
+  function normalizeActions(controller) {
+    controller.__actions__ = flatten(map(controller.actions, function(action) {
+      return normalizeAction(action);
+    }));
   }
 
-  /**
-   * Create a list of maps of action name/method pairs.
-   *
-   * @private
-   * @method createActionMap
-   * @param {String} method to map to action
-   * @param {String} action to map to method
-  */
-  function createActionMap(method, action) {
-    return { name: action, method: method };
+  function normalizeAction(action) {
+    return isObject(action) ? map(action, createActionObject) : [createActionObject(action, action)];
   }
 
-  /**
-   * Take a controller and an actionMap and determine if
-   * the action is defined on the controller. If not, throw
-   * an error.
-   *
-   * @private
-   * @method ensureActionIsDefined
-   * @param {Controller} controller
-   * @param {Object} actionMap
-  */
-  function ensureActionIsDefined(controller, actionMap) {
-    if (!isFunc(controller[actionMap.method])) {
-      throw new Error(controller.name + ' action "' + actionMap.name + ":" + actionMap.method + '" method is undefined');
+  function createActionObject(method, name) {
+    return { name: name, method: method };
+  }
+
+  function ensureActionIsDefined(controller, action) {
+    if (!isFunction(controller[action.method])) {
+      throw new Error(controller.name + ' action "' + action.name + ":" + action.method + '" method is undefined');
     }
   }
 
-  /**
-   * Return an event name based on the controller properties
-   * that make up an event name.
-   *
-   * @private
-   * @method actionEventName
-   * @param {Controller} controller
-   * @param {String} action
-   * @return String
-  */
-  function actionEventName(controller, action) {
-    return compact([
-      controller.namespace,
-      controller.channel,
-      controller.controllerEventName,
-      action
-    ]).join(controller.eventSeparator);
+  function registerActions(controller) {
+    each(controller.__actions__, function(action) {
+      ensureActionIsDefined(controller, action);
+      controller.dispatcher.on(eventNameForAction(controller, action.name), controller[action.method], controller);
+    });
+  }
+
+  function normalizeControllerElements(controller) {
+    controller.__elements__ = reduce(controller.elements, function(memo, elements, action) {
+      memo[action] = normalizeElements(elements);
+      return memo;
+    }, {});
+  }
+
+  function normalizeElements(elements) {
+    return reduce(elements, function(memo, selector, name) {
+      if (_.isArray(selector)) selector = first(selector);
+      memo[name] = selector;
+      return memo;
+    }, {});
+  }
+
+  function normalizeControllerEvents(controller) {
+    controller.__events__ = reduce(controller.elements, function(memo, elements, action) {
+      memo[action] = normalizeEvents(elements);
+      return memo;
+    }, {});
+  }
+
+  function normalizeEvents(elements) {
+    return reduce(elements, function(memo, selector, name) {
+      if (_.isArray(selector)) memo["$" + name] = last(selector);
+
+      return memo;
+    }, {});
+  }
+
+  function isMappedAction(action) {
+    return action.name != action.method;
+  }
+
+  function nativeFind(selector) {
+    return document.querySelectorAll(selector);
+  }
+
+  function findInDOM(selector) {
+    var finder = $ ? $ : nativeFind;
+    return finder(selector);
   }
 
-  /**
-   * Iterate over the given controller's elements object
-   * and cache a reference to each selected element.
-   *
-   * @private
-   * @method cacheElements
-   * @param {Controller} controller
-   * @param {String} action
-  */
   function cacheElements(controller, action) {
-    if (reduceElements(controller.elements, first)[action]) {
-      each(reduceElements(controller.elements, first)[action], function(selector, name) {
-        controller["$" + name] = $(selector);
-      }, controller);
+    if (!action) throw new Error("JSkit.Controller.cacheElements: action is undefined");
+
+    var actionElements = controller.__elements__[action];
+
+    if (actionElements) {
+      each(actionElements, function(selector, name) {
+        var element = controller["$" + name] = findInDOM(selector);
+
+        if (!element.length) {
+          throw new Error("JSkit.Controller.cacheElements: " + selector + " is not in the DOM");
+        }
+      });
     }
   }
 
-  /**
-   * Iterate over the given action's events and register
-   * the event handlers on each element.
-   *
-   * @private
-   * @method registerEvents
-   * @param {Controller} controller
-   * @param {String} action
-  */
-  function registerEvents(controller, action) {
-    if (reduceElements(controller.elements, last)[action]) {
-      each(reduceElements(controller.elements, last)[action], function(eventMap, element) {
-        each(eventMap, function(method, evnt) {
-          var handler = controller[method];
-          var $element = controller["$" + element];
-          $element.on(evnt, handler);
-        }, controller);
-      }, controller);
-    }
+  function decorateCacheElements(controller) {
+    controller.cacheElements = function(action) {
+      return cacheElements(controller, action);
+    };
   }
 
-  /**
-   * Iterate over the controller's elements
-   * and register to cache each action's events.
-   *
-   * @private
-   * @method registerElementCaching
-   * @param {Controller} controller
-  */
-  function registerElementCaching(controller) {
-    each(reduceElements(controller.elements, first), function(elements, action) {
-      controller.dispatcher.before(actionEventName(controller, action), function() {
-        cacheElements(controller, action);
-      }, controller);
-    }, controller);
+  function registerActionEvents(controller, action) {
+    each(controller.__events__[action], function(events, element) {
+      if (!controller[element]) cacheElements(controller, action);
+      registerElementEvents(controller, element, events);
+    });
   }
 
-  /**
-   * Iterate over the controller's events
-   * and register to handle each action's element events.
-   *
-   * @private
-   * @method registerControllerEvents
-   * @param {Controller} controller
-  */
-  function registerControllerEvents(controller) {
-    each(reduceElements(controller.elements, last), function(eventMap, action) {
-      controller.dispatcher.on(actionEventName(controller, action), function() {
-        registerEvents(controller, action);
-      }, controller);
-    }, controller);
+  function registerElementEvents(controller, element, events) {
+    var eventsBinder = bind(eventsBinderFor(events), controller);
+    var on = bind($.prototype.on, controller[element]);
+    eventsBinder(on);
   }
 
-  /**
-   * Reduce the controller's elements object into an object
-   * that only contains either the elements to cache or the
-   * events to register to that element.
-   *
-   * @private
-   *
-   * @method reduceElements
-   * @param {Object} controller's elements object
-   * @param {Function} function to grab either head or tail (first, last)
-   * @return {Object}
-  */
-  function reduceElements(elements, accessMethod) {
-    return reduce(elements, function(memo, value, key) {
-      memo[key] = {};
-      each(value, function(v, k) {
-        memo[key][k] = accessMethod(flatten([v]));
+  function eventsBinderFor(events) {
+    if(events instanceof Function) {
+      return events;
+    }
+
+    return function(on) {
+      var controller = this;
+      each(events, function(handler, evnt) {
+        on(evnt, controller[handler]);
       });
-      return memo;
-    }, {});
+    };
+  }
+
+  function decorateRegisterEvents(controller) {
+    controller.registerEvents = function(action) {
+      return registerActionEvents(controller, action);
+    };
+  }
+
+  function registerCacheElementsForActions(controller) {
+    each(controller.__actions__, function(action) {
+      var eventName = eventNameForAction(controller, action.name);
+      controller.dispatcher.before(eventName, function() {
+        return cacheElements(controller, action.name);
+      })
+    });
+  }
+
+  function registerControllerElementEvents(controller) {
+    each(controller.__actions__, function(action) {
+      registerActionEvents(controller, action.name);
+    });
   }
 
   return {
-    /**
-     * Factory function to create fresh controller objects
-     * with the given attributes.
-     *
-     * @method create
-     * @static
-     * @param {Object} [attrs={}]
-     *
-     * @return {Controller}
-    */
     create: function(attrs) {
-      attrs = attrs || {};
-      if (!attrs.name) throw new Error("Controller.create(name): name is undefined");
-
+      attrs = extend({}, attrs);
+      if (!attrs.name) throw new Error("JSkit.Controller: name is undefined");
+      restrictKeywords(attrs);
       var controller = defaults(attrs, {
-        /**
-         * Array of actions to be wired up.
-         *
-         * @property actions
-         * @type Array
-         * @default []
-        */
         actions: [],
-        /**
-         * Namespace that controller events are namespaced under.
-         *
-         * @property namespace
-         * @type String
-         * @default ""
-        */
-        namespace: "",
-        /**
-         * Channel that controller events use under namespace.
-         *
-         * @property channel
-         * @type String
-         * @default "controller"
-        */
         channel: "controller",
-        /**
-         * Underscored name of controller for use in events.
-         *
-         * @property controllerEventName
-         * @type String
-         * @default "controller"
-        */
         controllerEventName: underscore(attrs.name),
-        /**
-         * Event dispatcher for registering events.
-         *
-         * @property dispatcher
-         * @type Dispatcher
-         * @default JSkit.Dispatcher.create()
-        */
         dispatcher: JSkit.Dispatcher.create(),
-        /**
-         * Object of element names/selectors to
-         * cache per action.
-         *
-         * @property elements
-         * @type Object
-         * @default {}
-        */
         elements: {},
-        /**
-         * Object of events for each action to
-         * register on given elements.
-         *
-         * @property events
-         * @type Object
-         * @default {}
-        */
         eventSeparator: ":",
-        /**
-         * Default implementation that commits no operation
-         * @method all
-        */
+        namespace: "",
+        initialize: function() {},
         all: function() {},
-        /**
-         * Default implementation that commits no operation
-         * @method initialize
-        */
-        initialize: function() {}
+        eventNameForAction: function(action) {
+          return eventNameForAction(this, action);
+        }
       });
+
       bindAll(controller);
-      controller.actions.unshift("all");
 
-      registerElementCaching(controller);
-      registerControllerEvents(controller);
+      registerAllAction(controller);
+      normalizeActions(controller);
       registerActions(controller);
 
+      normalizeControllerElements(controller);
+      normalizeControllerEvents(controller);
+
+      registerCacheElementsForActions(controller);
+      registerControllerElementEvents(controller);
+
+      decorateCacheElements(controller);
+      decorateRegisterEvents(controller);
+
       controller.initialize();
 
       return controller;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_jskit
 version: !ruby/object:Gem::Version
-  version: 5.0.2
+  version: 5.1.0
 platform: ruby
 authors:
 - Dayton Nolan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-08 00:00:00.000000000 Z
+date: 2015-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -170,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Gem that provides Rails integration for jskit