voltron 0.2.10

data/app/assets/javascripts/voltron-dispatch.js

@@ -0,0 +1,159 @@
+//= require voltron-ext
+//= require voltron-core
+
+Voltron.addModule('Dispatch', function(){
+  var _events = {}
+      _globals = {};
+
+  return {
+    addEventWatcher: function(event){
+      var args = Array.prototype.slice.call(arguments, 1).flatten().compact();
+      _events[event] = args;
+      $.each(args, function(index, evt){
+        if(['element', 'event', 'data'].includes(evt.toLowerCase())){
+          Voltron.debug('error', 'Provided event watcher argument %o is a reserved observer param and will be overridden when the event is dispatched. Consider changing the name of the argument in your call to addEventWatcher for %o', evt, event);
+        }
+      });
+      Voltron.debug('info', 'Added event watcher for %o', event);
+      return this.listen();
+    },
+
+    addGlobalEvent: function(event, selector){
+      var options = this.getDispatchOptions(event, { data: {} }, {});
+      event = Object.keys(options).first();
+      var module = options[event].module;
+      var alias = options[event].alias;
+      if(!$.isArray(_globals[event])) _globals[event] = [];
+      _globals[event].push({ selector: selector, alias: alias, module: module });
+      return this.listen();
+    },
+
+    listen: function(){
+      $(document).off('.voltron').off('.voltron_global');
+      $(document).on(this.getEvents(), '[data-dispatch]', this.trigger);
+
+      var globals = this.getGlobalEvents();
+      for(var i=0; i<globals.length; i++){
+        for(var j=0; j<globals[i].data.length; j++){
+          $(document).on(globals[i].event, [globals[i].data[j].selector].flatten().join(', '), this.getGlobalCallback(globals[i].data[j]))
+        }
+      }
+
+      return this;
+    },
+
+    getEvents: function(){
+      return $.map(_events, function(val,key){
+        return key + '.voltron';
+      }).join(' ');
+    },
+
+    getGlobalEvents: function(){
+      return $.map(_globals, function(val,key){
+        return { event: key + '.voltron_global', data: val };
+      });
+    },
+
+    getGlobalCallback: function(data){
+      return function(event){
+        // In case the element in question has a data-dispatch attribute already, don't overwrite it
+        // We'll restore the existing data after we trigger the event
+        var oldDispatch = $(this).data('dispatch');
+        $(this).data('dispatch', [[data.module, event.type].compact().join(':'), data.alias].compact().join('/') );
+        Voltron.getModule('Dispatch').trigger.call(this, event);
+        $(this).data('dispatch', oldDispatch);
+      };
+    },
+
+    getSelectors: function(event){
+      var pattern = new RegExp(event);
+      return $.map(_globals, function(val,key){
+        if(pattern.test(key)){
+          var selectors = val.map(function(v){ return v.selector; });
+          return selectors.flatten();
+        }
+      }).flatten().compact();
+    },
+
+    getHash: function(keys, vals){
+      return keys.length === vals.length ? keys.reduce(function(obj, key, index){
+        obj[key] = vals[index];
+        return obj;
+      }, {}) : {};
+    },
+
+    getArgumentHash: function(event, args){
+      if(_events[event]){
+        return this.getHash(_events[event], args);
+      }
+      return {};
+    },
+
+    trigger: function(event){
+      if($(this).data('dispatch')){
+        var args = Voltron('Dispatch/getArgumentHash', event.type, Array.prototype.slice.call(arguments, 1));
+        var params = $.extend(args, { element: this, event: event, data: $(this).data() });
+
+        var dispatches = params.data.dispatch.split(/\s+/);
+        var events = {};
+
+        for(var i=0; i<dispatches.length; i++){
+          events = $.extend(events, Voltron('Dispatch/getDispatchOptions', dispatches[i], params, this));
+        }
+
+        if(events[event.type]){
+          var alias = events[event.type]['alias'];
+          var moduleName = events[event.type]['module'];
+
+          if(Voltron.hasModule(moduleName)){
+            var module = Voltron.getModule(moduleName);
+            var aliasMethod = Voltron('Dispatch/getDispatchMethod', event.type, alias);
+
+            if(module.canReceiveEvents()){
+              if($.isFunction(module[aliasMethod])){
+                module[aliasMethod](params);
+                Voltron.debug('info', 'Dispatching callback function %o in the %o module with observer object: %o', aliasMethod, module.name(), params);
+              }else if(!$.isFunction(module[aliasMethod])){
+                Voltron.debug('warn', 'Callback function %o was not found in the %o module. Try defining it, or remove %o from your element\'s data-dispatch attribute if the event does not need to be observed', aliasMethod, module.name(), event.type);
+                return;
+              }else{
+                Voltron.debug('log', 'Attempted to dispatch %o in %o module with observer object: %o', aliasMethod, module.name(), params);
+              }
+            }
+          }else if(Voltron._modules[moduleName.toLowerCase()]){
+            Voltron.debug('log', 'Tried to dispatch the %o event, but the module %o does not exist. Triggered on element: %o', event.type, moduleName, this);
+          }
+        }
+      }
+    },
+
+    getDispatchOptions: function(dispatch, params, element){
+      var defaultModule = params.data.module || Voltron.getConfig('controller');
+      var defaultAlias = element.id || element.tagName;
+      var options = [];
+
+      if((matches = dispatch.match(/^([a-z_\-]+):([a-z\_\-:]+)\/([a-z\_\-]+)/i)) !== null){
+        // Match format: "module:action/alias"
+        options[matches[2]] = { alias: matches[3], module: matches[1] };
+      }else if((matches = dispatch.match(/^([a-z\_\-:]+)\/([a-z\_\-]+)/i)) !== null){
+        // Match format: "action/alias", using default module
+        options[matches[1]] = { alias: matches[2], module: defaultModule };
+      }else if((matches = dispatch.match(/^([a-z_\-]+):([a-z\_\-:]+)/i)) !== null){
+        // Match format: "module:action", using default alias
+        options[matches[2]] = { alias: defaultAlias, module: matches[1] };
+      }else{
+        // Match everthing else as if no alias or module was defined, use defaults for both
+        options[dispatch.toLowerCase()] = { alias: defaultAlias, module: defaultModule };
+      }
+      return options;
+    },
+
+    getDispatchMethod: function(event, alias){
+      return ['on', event, alias].compact().join('_')
+        .replace(/[^a-z0-9\_\-:]+/ig, '')
+        .replace(/([a-z0-9])([A-Z])/g, function(match){ return [match[0], match[1]].join('_') })
+        .toLowerCase()
+        .replace(/_([a-z0-9])|\-([a-z0-9])|:([a-z0-9])/ig, function(match){ return match[1].toUpperCase(); });
+    }
+  };
+}, true);

data/app/assets/javascripts/voltron-ext.js

@@ -0,0 +1,122 @@
+// String
+
+String.prototype.trim = function(what){
+  var out = $.trim(this);
+  if(what){
+    var re = new RegExp('^' + what.toString() + '|' + what.toString() + '$');
+    out = out.replace(re, '');
+  }
+  return $.trim(out);
+};
+
+String.prototype.blank = function(){
+  return this.trim() == '';
+};
+
+String.prototype.startsWith = function(what){
+  var re = new RegExp('^' + what.toString());
+  return re.test(this.trim());
+};
+
+String.prototype.endsWidth = function(what){
+  var re = new RegExp(what.toString() + '$');
+  return re.test(this.trim());
+};
+
+String.prototype.contains = function(what){
+  var re = new RegExp(what.toString(), 'i');
+  return re.test(this);
+};
+
+// Array
+
+Array.prototype.compact = function(){
+  for(var i=0; i<this.length; i++){
+    if(!this[i] || (typeof this[i].blank == 'function' && this[i].blank())){
+      this.splice(i, 1);
+      i--;
+    }
+  }
+  return this;
+};
+
+Array.prototype.includes = function(what){
+  if(typeof what == 'object'){
+    var re = new RegExp(what);
+    for(var i=0; i<this.length; i++){
+      if(re.test(this[i].toString())){
+        return true;
+      }
+    }
+  }else{
+    for(var i=0; i<this.length; i++){
+      if(this[i] == what){
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+Array.prototype.flatten = function(){
+  var b = Array.prototype.concat.apply([], this);
+  if(b.length != this.length){
+    b = b.flatten();
+  };
+
+  return b;
+};
+
+Array.prototype.blank = function(){
+  return this.compact().length == 0;
+};
+
+Array.prototype.uniq = function(){
+  var u = {}, a = [];
+  for(var i=0, l=this.length; i<l; ++i){
+    if(u.hasOwnProperty(this[i])){
+      continue;
+    }
+    a.push(this[i]);
+    u[this[i]] = 1;
+  }
+  return a;
+};
+
+Array.prototype.first = function(){
+  return this[0];
+};
+
+Array.prototype.last = function(){
+  return this[this.length-1];
+};
+
+Array.prototype.any = function(callback){
+  for(var i=0; i<this.length; i++){
+    if(callback(this[i])){
+      return true;
+    }
+  }
+  return false;
+};
+
+Array.prototype.all = function(callback){
+  for(var i=0; i<this.length; i++){
+    if(!callback(this[i])){
+      return false;
+    }
+  }
+  return true;
+};
+
+// Boolean
+
+Boolean.prototype.blank = function(){
+  return this === false;
+};
+
+// Number
+
+Number.prototype.blank = function(){
+  return this <= 0;
+};

data/app/assets/javascripts/voltron-observer.js

@@ -0,0 +1,156 @@
+//= require voltron
+
+/**
+ * Voltron::Observer
+ *
+ * Adds ability to monitor DOM events that can be observed by means of the +Voltron.on()+ method
+ *
+ * List of events that can now be observed:
+ *
+ *   +append+ When an element is append to the DOM
+ *   +remove+ When an element is removed from the DOM
+ *   +conceal+ When an element on the DOM is hidden (defined as the result of jQuery's `:hidden` selector)
+ *   +reveal+ When an element on the DOM is displayed (defined as the result of jQuery's `:visible` selector)
+ *
+ * Example usage, from within any method defined in a Voltron module:
+ *
+ *   Voltron.on('append:div', function(o){
+ *     // Do things with the appended element, context is +Voltron+
+ *   });
+ *   
+ *   OR
+ *
+ *   this.on('append:div', function(o){
+ *     // Do things with the appended element, context is the module in which this observer was defined
+ *   });
+ *
+ */
+Voltron.addModule('Observer', '*', function(){
+  'use strict';
+
+  var _observer = null;
+
+  var _defaults = {
+    subtree: true,
+    childList: true,
+    characterData: false,
+    attributes: true,
+    attributeFilter: ['style', 'class']
+  };
+
+  return {
+    initialize: function(options){
+      options = $.extend(_defaults, options);
+      this.getObserver().observe(document.body, options);
+
+      // Trigger append and reveal events on start up for appropriate elements
+      $(this.getElements('append')).trigger('append');
+      $(this.getElements('reveal')).filter(function(){
+        return Voltron('Observer/isVisible', this);
+      }).trigger('reveal');
+    },
+
+    stop: function(){
+      this.getObserver().disconnect();
+    },
+
+    process: function(mutations){
+      // Get a unique array of DOM elements that each has the associated mutation as a part of it's dataset
+      var elements = this.getMutationElements(mutations);
+
+      // Iterate through each element, dispatching the appropriate event for each elements mutation
+      for(var i=0; i<elements.length; i++){
+        var mutation = $(elements[i]).data('_mutation');
+
+        if(!mutation || !mutation.type) continue;
+
+        if(mutation.type == 'childList'){
+          // Flag nodes that have been added, and don't dispatch on any that have
+          // This solves the issue of recursion if an element that dispatches `added` is moved in the DOM
+          // Also dispatch only on elements that are configured to have `added` dispatched,
+          // including the element itself if applicable
+          $(mutation.addedNodes).filter(function(){
+            return !$(this).data('_mutation_appended');
+          }).data('_mutation_appended', true)
+            .find(this.getElements('append', 'reveal'))
+            .addBack(this.getElements('append', 'reveal'))
+            .trigger('append').filter(function(){
+              return Voltron('Observer/isVisible', this);
+            }).trigger('reveal');
+
+          // Flag nodes that have been removed to avoid unnecessary dispatching
+          // Dispatch the removed event on any child elements configured to do so,
+          // including the element itself if applicable
+          // Event must be dispatched manually since at this point the element no
+          // longer exists in the DOM, and can't be trigger()'ed
+          $(mutation.removedNodes).filter(function(){
+            return !$(this).data('_mutation_removed');
+          }).data('_mutation_removed', true)
+            .find(this.getElements('remove', 'conceal'))
+            .addBack(this.getElements('remove', 'conceal'))
+            .each(function(){
+              Voltron.getModule('Dispatch').trigger.call(this, $.Event('remove', { target: this }));
+              Voltron.getModule('Dispatch').trigger.call(this, $.Event('conceal', { target: this }));
+            });
+        }else if(mutation.type == 'attributes'){
+          var target = $(mutation.target);
+          // If currently animating, break out. We only want to dispatch when the state is truly reached
+          if(target.is(':animated')) break;
+
+          if(!this.isVisible(mutation.target)){
+            target.find(this.getElements('conceal')).trigger('conceal');
+          }else if(this.isVisible(mutation.target)){
+            target.find(this.getElements('reveal')).filter(function(){
+              return Voltron('Observer/isVisible', this);
+            }).trigger('reveal');
+          }
+        }
+      }
+    },
+
+    getObserver: function(){
+      if(_observer === null){
+        _observer = new MutationObserver($.proxy(function(mutations){
+          // Process all of the elements with mutations
+          this.process(mutations);
+        }, this));
+      }
+      return _observer;
+    },
+
+    getMutationElements: function(mutations){
+      if($.isFunction($.uniqueSort)){
+        // >= jQuery 3
+        return $.uniqueSort($.map(mutations, function(mut){
+          return $(mut.target).data('_mutation', mut).get(0);
+        }));
+      }else{
+        // < jQuery 3
+        return $.unique($.map(mutations, function(mut){
+          return $(mut.target).data('_mutation', mut).get(0);
+        }));
+      }
+    },
+
+    getElements: function(){
+      return $.map(Array.prototype.slice.call(arguments, 0), function(dispatch){
+        return ['[data-dispatch*="' + dispatch + '"]', Voltron('Dispatch/getSelectors', dispatch)];
+      }).flatten().join(', ');
+    },
+
+    isVisible: function(element){
+      var i = 0,
+          visible = $(element).is(':visible');
+
+      while(element.tagName !== 'BODY'){
+        if($(element).is(':hidden') || $(element).width() == 0 || $(element).height() == 0) return false;
+        // Limit to only traversing up 200 DOM elements before we hit the body tag
+        // If we go that far and still don't reach the body tag, something's up
+        // or the html is beyond crappy.
+        if(i++ >= 200) break;
+        element = $(element).parent().get(0);
+      }
+      return true && visible;
+    }
+  };
+}, true);

data/app/assets/javascripts/voltron.js

@@ -0,0 +1,3 @@
+//= require voltron-ext
+//= require voltron-core
+//= require voltron-dispatch

data/app/helpers/voltron_helper.rb

@@ -0,0 +1,11 @@
+module VoltronHelper
+
+  def voltron_include_tag
+    javascript_tag "Voltron.initialize(#{voltron_config_json});", type: 'text/javascript'
+  end
+
+  def voltron_config_json
+    Voltron.config.to_h.merge({ controller: controller_name, action: action_name }).to_json.html_safe
+  end
+
+end