xooie 1.0.4 → 1.0.5

data/vendor/assets/javascripts/xooie/widgets/tab.js

@@ -24,16 +24,17 @@
  * The Tab widget should be used as a way to organize how content is displayed
  * visually.  Content is hidden until the associated tab is activated.
  **/
-define('xooie/widgets/tab', ['jquery', 'xooie/helpers', 'xooie/widgets/base', 'xooie/event_handler'], function($, helpers, Base, EventHandler) {
+define('xooie/widgets/tab', ['jquery', 'xooie/helpers', 'xooie/widgets/base', 'xooie/event_handler'], function ($, helpers, Base, EventHandler) {
+  'use strict';
 
   function setSelection(widget, selectedTabs) {
     var activeTabs = widget.getActiveTabs();
 
-    activeTabs.not(selectedTabs).each(function() {
+    activeTabs.not(selectedTabs).each(function () {
       widget.deactivateTab($(this));
     });
 
-    selectedTabs.not(activeTabs).each(function() {
+    selectedTabs.not(activeTabs).each(function () {
       widget.activateTab($(this));
     });
   }
@@ -64,31 +65,31 @@ define('xooie/widgets/tab', ['jquery', 'xooie/helpers', 'xooie/widgets/base', 'x
  *
  * Instantiates a new Tab instance.  See [[Xooie.Widget]] for more functionality.
  **/
-  var Tab = Base.extend(function(){
+  var Tab = Base.extend(function () {
     var self = this;
 
     this._tabEvents = new EventHandler(this.namespace());
 
     this._tabEvents.add({
-      keyup: function(event){
-        if ([13,32].indexOf(event.which) !== -1){
-          setSelection(self, self.selectTabs(event, $(this)));
+      keyup: function (event) {
+        if ([13, 32].indexOf(event.which) !== -1) {
+          setSelection(self, self.selectTabs($(this), event));
 
           event.preventDefault();
         }
       },
 
-      mouseup: function(event){
-        setSelection(self, self.selectTabs(event, $(this)));
+      mouseup: function (event) {
+        setSelection(self, self.selectTabs($(this), event));
       },
 
-      click: function(event){
+      click: function (event) {
         event.preventDefault();
       }
     });
 
     // TODO: Test and document this.  Also, create a property for data-activate
-    this.root().on(this.initEvent(), function(){
+    this.root().on(this.initEvent(), function () {
       self.activateTab(self.tabs().filter('[data-activate="true"]'));
     });
 
@@ -173,7 +174,7 @@ define('xooie/widgets/tab', ['jquery', 'xooie/helpers', 'xooie/widgets/base', 'x
  * The method also activates the [[Xooie.Tab#tabpanels]] that is indicated by the tab's `aria-controls` attribute,
  * adding the [[Xooie.Tab#activeClass]] class and setting `aria-expanded` to 'true'.
  **/
-  Tab.prototype.activateTab = function(tab) {
+  Tab.prototype.activateTab = function (tab) {
     tab.addClass(this.activeClass())
        .attr('aria-selected', true);
 
@@ -196,7 +197,7 @@ define('xooie/widgets/tab', ['jquery', 'xooie/helpers', 'xooie/widgets/base', 'x
  * The method also deactivates the [[Xooie.Tab#tabpanels]] that is indicated by the tab's `aria-controls` attribute,
  * removing the [[Xooie.Tab#activeClass]] class and setting `aria-expanded` to 'false'.
  **/
-  Tab.prototype.deactivateTab = function(tab) {
+  Tab.prototype.deactivateTab = function (tab) {
     tab.removeClass(this.activeClass())
        .attr('aria-selected', false);
 
@@ -211,9 +212,9 @@ define('xooie/widgets/tab', ['jquery', 'xooie/helpers', 'xooie/widgets/base', 'x
   };
 
 /**
- * Xooie.Tab#selectTabs(event, selectedTab)
- * - event (Event): Browser event that triggered selectTabs call
+ * Xooie.Tab#selectTabs(selectedTab, event)
  * - selectedTab (Element): Tab that was selected by a mouse or keyboard event
+ * - event (Event): The jQuery event that triggered the selection
  *
  * Only called by mouse/keyboard event handlers to generate the list of
  * currently active tabs. Should return a jQuery collection of tabs that are
@@ -223,7 +224,7 @@ define('xooie/widgets/tab', ['jquery', 'xooie/helpers', 'xooie/widgets/base', 'x
  *
  * Override this method to alter the behavior of the Tab widget.
  **/
-  Tab.prototype.selectTabs = function(event, selectedTab) {
+  Tab.prototype.selectTabs = function (selectedTab) {
     return selectedTab;
   };
 
@@ -233,7 +234,7 @@ define('xooie/widgets/tab', ['jquery', 'xooie/helpers', 'xooie/widgets/base', 'x
  * Returns a jQuery-selected collection of all [[Xooie.Tab#tabs]] that currently have the
  * [[Xooie.Tab#activeClass]] class.
  **/
-  Tab.prototype.getActiveTabs = function() {
+  Tab.prototype.getActiveTabs = function () {
     return this.tabs().filter('.' + this.activeClass());
   };
 
@@ -245,28 +246,30 @@ define('xooie/widgets/tab', ['jquery', 'xooie/helpers', 'xooie/widgets/base', 'x
  * the `data-x-role="tab"` attribute.  Tabs are given the [`role="tab"`](http://www.w3.org/TR/wai-aria/roles#tab) and [`aria-selected="false"`](http://www.w3.org/TR/wai-aria/states_and_properties#aria-selected)
  * [ARIA](http://www.w3.org/TR/wai-aria/) attributes.
  **/
-  Tab.prototype._process_role_tab = function(tabs){
-    var tabpanels = this.tabpanels(),
-        tab, panelId,
-        self = this;
+  Tab.prototype._process_role_tab = function (tabs) {
+    var tabpanels;
+
+    tabpanels = this.tabpanels();
 
     tabs.attr('role', 'tab')
         .attr('aria-selected', false);
 
-    tabs.each(function(index) {
+    tabs.each(function (index) {
+      var tab, panelId;
+
       tab = $(this);
       panelId = tabpanels.eq(index).attr('id');
 
-      $(this).attr('aria-controls', panelId);
+      tab.attr('aria-controls', panelId);
 
-      if ($(this).is('a')) {
-        $(this).attr('href', '#' + panelId);
+      if (tab.is('a')) {
+        tab.attr('href', '#' + panelId);
       }
 
     });
 
     tabs.on(this._tabEvents.handlers);
-    
+
     return tabs;
   };
 
@@ -277,12 +280,11 @@ define('xooie/widgets/tab', ['jquery', 'xooie/helpers', 'xooie/widgets/base', 'x
  * defined then its value will be used to select from the DOM.  Otherwise, tabs will be selected from decendants of
  * the root using the `[data-x-role="tab"]` selector.
  **/
-  Tab.prototype._get_role_tab = function(){
+  Tab.prototype._get_role_tab = function () {
     if (!helpers.isUndefined(this.tabSelector())) {
       return $(this.tabSelector());
-    } else {
-      return this.root().find('[data-x-role="tab"]');
     }
+    return this.root().find('[data-x-role="tab"]');
   };
 
 /** internal
@@ -290,9 +292,7 @@ define('xooie/widgets/tab', ['jquery', 'xooie/helpers', 'xooie/widgets/base', 'x
  *
  * TODO: Create this method to keep parity with the existing tab functionality
  **/
-  Tab.prototype._render_role_tab = function(){
-
-  };
+  Tab.prototype._render_role_tab = function () { return false; };
 
 /** internal
  * Xooie.Tab#_process_role_tablist(tablist) -> Element
@@ -303,12 +303,12 @@ define('xooie/widgets/tab', ['jquery', 'xooie/helpers', 'xooie/widgets/base', 'x
  * [ARIA](http://www.w3.org/TR/wai-aria/) attributes.  If any [[Xooie.Tab#tabs]] are not decendants of the tab list, the ids of those
  * tabs are added to the [`aria-owns`](http://www.w3.org/TR/wai-aria/states_and_properties#aria-owns) attribute.
  **/
-  Tab.prototype._process_role_tablist = function(tablist) {
+  Tab.prototype._process_role_tablist = function (tablist) {
     var tabs = this.tabs();
 
     tablist.attr('role', 'tablist');
 
-    tabs.each(function(index) {
+    tabs.each(function () {
       var owns, id;
       if (tablist.has(this).length === 0) {
         owns = tablist.attr('aria-owns') || '';
@@ -332,7 +332,7 @@ define('xooie/widgets/tab', ['jquery', 'xooie/helpers', 'xooie/widgets/base', 'x
  *
  * TODO: Add this method to render the tablist if it is not included.
  **/
-  Tab.prototype._render_role_tablist = function(){
+  Tab.prototype._render_role_tablist = function () {
     return $('<ul data-x-role="tablist"></ul>');
   };
 
@@ -344,7 +344,7 @@ define('xooie/widgets/tab', ['jquery', 'xooie/helpers', 'xooie/widgets/base', 'x
  * the `data-x-role="tabpanel"` attribute.  Tabs are given the [`role="tabpanel"`](http://www.w3.org/TR/wai-aria/roles#tab) and [`aria-expanded="false"`](http://www.w3.org/TR/wai-aria/states_and_properties#aria-selected)
  * [ARIA](http://www.w3.org/TR/wai-aria/) attributes.
  **/
-  Tab.prototype._process_role_tabpanel = function(tabpanels) {
+  Tab.prototype._process_role_tabpanel = function (tabpanels) {
     tabpanels.attr('role', 'tabpanel')
              .attr('aria-expanded', false);
 

data/vendor/assets/javascripts/xooie/xooie.js

@@ -31,31 +31,32 @@ var $X, Xooie;
  * widget for every element that has a data-widget-type attribute.
  **/
 
-$X = Xooie = (function(static_config) {
-    var config = {
-            widgets: {},
-            addons: {}
-        },
-        obj = function() {
-            return false;
-        },
-        gcTimer = null;
-
-    function copyObj(dst, src) {
-        var name;
-
-        for (name in src) {
-            if (src.hasOwnProperty(name)) {
-                dst[name] = src[name];
-            }
-        }
+$X = Xooie = (function (static_config) {
+  'use strict';
+  var config = {
+      widgets: {},
+      addons: {}
+    },
+    obj = function () {
+      return false;
+    },
+    gcTimer = null;
+
+  function copyObj(dst, src) {
+    var name;
+
+    for (name in src) {
+      if (src.hasOwnProperty(name)) {
+        dst[name] = src[name];
+      }
     }
+  }
 
-    function gcCallback() {
-        if (typeof Xooie.cleanup !== 'undefined') {
-            Xooie.cleanup();
-        }
+  function gcCallback() {
+    if (Xooie.cleanup !== undefined) {
+      Xooie.cleanup();
     }
+  }
 
 /**
  * $X.config(options)
@@ -76,27 +77,27 @@ $X = Xooie = (function(static_config) {
  * Default: `0`.
  **/
 
-    obj.config = function(options) {
-        var name;
-
-        for (name in options) {
-            if (options.hasOwnProperty(name)) {
-                if (name === 'widgets' || name == 'addons') {
-                    copyObj(config[name], options[name]);
-                } else {
-                    config[name] = options[name];
-                }
-            }
+  obj.config = function (options) {
+    var name;
+
+    for (name in options) {
+      if (options.hasOwnProperty(name)) {
+        if (name === 'widgets' || name === 'addons') {
+          copyObj(config[name], options[name]);
+        } else {
+          config[name] = options[name];
         }
+      }
+    }
 
-        if (typeof options.cleanupInterval !== 'undefined') {
-            gcTimer = clearInterval(gcTimer);
+    if (options.cleanupInterval !== undefined) {
+      gcTimer = clearInterval(gcTimer);
 
-            if (config.cleanupInterval > 0) {
-                gcTimer = setInterval(gcCallback, config.cleanupInterval);
-            }
-        }
-    };
+      if (config.cleanupInterval > 0) {
+        gcTimer = setInterval(gcCallback, config.cleanupInterval);
+      }
+    }
+  };
 
 /** internal
  * $X._mapName(name, type) -> String
@@ -106,143 +107,143 @@ $X = Xooie = (function(static_config) {
  * Maps the name of the widget or addon to the correct url string where the module file is located.
  **/
 
-    obj._mapName = function(name, type) {
-        if (typeof config[type][name] === 'undefined') {
-            return [config.root, '/', type, '/', name].join('');
-        } else {
-            return config[type][name];
-        }
-    };
+  obj._mapName = function (name, type) {
+    if (config[type][name] === undefined) {
+      return [config.root, '/', type, '/', name].join('');
+    }
+    return config[type][name];
+  };
 
-    obj.config({
-        root: 'xooie',
-        cleanupInterval: 0
-    });
+  obj.config({
+    root: 'xooie',
+    cleanupInterval: 0
+  });
 
-    if (static_config) {
-        obj.config(static_config);
-    }
+  if (static_config) {
+    obj.config(static_config);
+  }
 
-    return obj;
+  return obj;
 }(Xooie));
 
-define('xooie/xooie', ['jquery', 'xooie/helpers', 'xooie/stylesheet'], function($, helpers, Stylesheet){
-    var config = Xooie.config,
-        _mapName = Xooie._mapName,
-        widgetSelector = '[data-widget-type]';
-        widgetDataAttr = 'widgetType';
-        addonDataAttr = 'addons';
+define('xooie/xooie', ['jquery', 'xooie/helpers', 'xooie/stylesheet'], function ($, helpers, Stylesheet) {
+  'use strict';
+  var config, _mapName, widgetSelector, widgetDataAttr, addonDataAttr;
 
-    $X = Xooie = function(element){
-        var nodes, moduleNames, moduleUrls,
-            node, url,
-            i, j;
+  config = Xooie.config;
+  _mapName = Xooie._mapName;
+  widgetSelector = '[data-widget-type]';
+  widgetDataAttr = 'widgetType';
+  addonDataAttr = 'addons';
 
-        element = $(element);
+  $X = Xooie = function (element) {
+    var node, nodes, moduleNames, moduleUrls, url, i, j;
 
-        // Find all elements labeled as widgets:
-        nodes = element.find(widgetSelector);
+    element = $(element);
 
-        // If the element is also tagged, add it to the collection:
-        if (element.is(widgetSelector)){
-            nodes = nodes.add(element);
-        }
+    // Find all elements labeled as widgets:
+    nodes = element.find(widgetSelector);
 
-        // This array will be the list of unique modules to load:
-        moduleUrls = [];
+    // If the element is also tagged, add it to the collection:
+    if (element.is(widgetSelector)) {
+      nodes = nodes.add(element);
+    }
+
+    // This array will be the list of unique modules to load:
+    moduleUrls = [];
 
-        // Iterate through each item in the collection:
-        for(i = 0; i < nodes.length; i+=1) {
-            node = $(nodes[i]);
+    // Iterate through each item in the collection:
+    for (i = 0; i < nodes.length; i += 1) {
+      node = $(nodes[i]);
 
-            // Add all of the widget types to the list of modules we need:
-            moduleNames = helpers.toAry(node.data(widgetDataAttr));
+      // Add all of the widget types to the list of modules we need:
+      moduleNames = helpers.toAry(node.data(widgetDataAttr));
 
-            // For each widget we check to see if the url is already in our
-            // list of urls to require:
-            for (j = 0; j < moduleNames.length; j+=1) {
-                url = $X._mapName(moduleNames[j], 'widgets');
+      // For each widget we check to see if the url is already in our
+      // list of urls to require:
+      for (j = 0; j < moduleNames.length; j += 1) {
+        url = $X._mapName(moduleNames[j], 'widgets');
 
-                if (moduleUrls.indexOf(url) === -1) {
-                    moduleUrls.push(url);
-                }
-            }
+        if (moduleUrls.indexOf(url) === -1) {
+          moduleUrls.push(url);
+        }
+      }
 
-            // Do the same with each addon name:
-            moduleNames = helpers.toAry(node.data(addonDataAttr)) || [];
+      // Do the same with each addon name:
+      moduleNames = helpers.toAry(node.data(addonDataAttr)) || [];
 
-            for (j = 0; j < moduleNames.length; j+=1) {
-                url = $X._mapName(moduleNames[j], 'addons');
+      for (j = 0; j < moduleNames.length; j += 1) {
+        url = $X._mapName(moduleNames[j], 'addons');
 
-                if (moduleUrls.indexOf(url) === -1) {
-                    moduleUrls.push(url);
-                }
-            }
+        if (moduleUrls.indexOf(url) === -1) {
+          moduleUrls.push(url);
         }
+      }
+    }
 
-        // Now that we have a list of urls to load, let's load them:
-        require(moduleUrls, function(){
-            var widgets, addons, node,
-                addonMods, widgetMod, argIndex,
-                i, j, k;
+    // Now that we have a list of urls to load, let's load them:
+    require(moduleUrls, function () {
+      var widgets, addons, addonMods, WidgetMod, argIndex, instances, k;
 
-            // We need to iterate through our collection of nodes again:
-            for (i = 0; i < nodes.length; i+=1) {
-                node = $(nodes[i]);
+      instances = [];
 
-                // This time, we're keeping track of our addons and widges separately:
-                widgets = helpers.toAry(node.data(widgetDataAttr));
-                addons = helpers.toAry(node.data(addonDataAttr)) || [];
+      // We need to iterate through our collection of nodes again:
+      for (i = 0; i < nodes.length; i += 1) {
+        node = $(nodes[i]);
 
-                // Iterate through each widget type:
-                for (j = 0; j < widgets.length; j+=1) {
+        // This time, we're keeping track of our addons and widges separately:
+        widgets = helpers.toAry(node.data(widgetDataAttr));
+        addons = helpers.toAry(node.data(addonDataAttr)) || [];
 
-                    // Get the index of this module from the moduleUrls:
-                    argIndex = moduleUrls.indexOf($X._mapName(widgets[j], 'widgets'));
+        // Iterate through each widget type:
+        for (j = 0; j < widgets.length; j += 1) {
 
-                    //Get the widget that we'll be instantiating:
-                    widgetMod = arguments[argIndex];
+          // Get the index of this module from the moduleUrls:
+          argIndex = moduleUrls.indexOf($X._mapName(widgets[j], 'widgets'));
 
-                    addonMods = [];
+          //Get the widget that we'll be instantiating:
+          WidgetMod = arguments[argIndex];
 
-                    // Now get each addon that we'll instantiate with the widget:
-                    for (k = 0; k < addons.length; k+=1) {
-                        // Get the index of the addon module from moduleUrls:
-                        argIndex = moduleUrls.indexOf($X._mapName(addons[k], 'addons'));
+          addonMods = [];
 
-                        addonMods.push(arguments[argIndex]);
-                    }
+          // Now get each addon that we'll instantiate with the widget:
+          for (k = 0; k < addons.length; k += 1) {
+            // Get the index of the addon module from moduleUrls:
+            argIndex = moduleUrls.indexOf($X._mapName(addons[k], 'addons'));
 
-                    // Instantiate the new instance using the argIndex to find the right module:
-                    new widgetMod(node, addonMods);
-                }
-            }
-        });
-    };
+            addonMods.push(arguments[argIndex]);
+          }
+
+          // Instantiate the new instance using the argIndex to find the right module:
+          instances.push(new WidgetMod(node, addonMods));
+        }
+      }
+    });
+  };
 
-    Xooie.config = config;
-    Xooie._mapName = _mapName;
+  Xooie.config = config;
+  Xooie._mapName = _mapName;
 
 /** internal, read-only
  * $X._stylesheet -> Object
  *
  * An instance of the [[Stylesheet]] class used to manipluate a dynamically created Xooie stylesheet
  **/
-    Xooie._stylesheet = new Stylesheet('Xooie');
+  Xooie._stylesheet = new Stylesheet('Xooie');
 
 /** internal
  * $X._styleRules -> Object
  *
  * A cache of css rules defined by the [[Xooie.Widget.createStyleRule]] method.
  **/
-    Xooie._styleRules = {};
+  Xooie._styleRules = {};
 
 /** internal
  * $X._instanceCache -> Array
  *
  * A collection of currently instantiated widgets.
  **/
-    Xooie._instanceCache = [];
+  Xooie._instanceCache = [];
 
 /** internal
  * $X._instanceIndex -> Integer
@@ -250,8 +251,8 @@ define('xooie/xooie', ['jquery', 'xooie/helpers', 'xooie/stylesheet'], function(
  * Tracks the next available instance index in the cache.  This value also serves as the id of the
  * next instantiated widget.
  **/
-    Xooie._instanceIndex = 0;
-    
+  Xooie._instanceIndex = 0;
+
 /**
  * $X.cleanup()
  *
@@ -259,24 +260,26 @@ define('xooie/xooie', ['jquery', 'xooie/helpers', 'xooie/stylesheet'], function(
  * root element is no longer in the DOM, the module is garbage collected.
  **/
 
-    Xooie.cleanup = function() {
-        var i, instance;
+  Xooie.cleanup = function () {
+    var i, instance;
 
-        for (i = 0; i < $X._instanceCache.length; i++) {
-            instance = $X._instanceCache[i];
+    for (i = 0; i < $X._instanceCache.length; i += 1) {
+      instance = $X._instanceCache[i];
 
-            if (instance.root() && instance.root().parents('body').length === 0) {
-                instance.cleanup();
-                delete $X._instanceCache[i];
-            }
-        }
-    };
+      if (instance.root() && instance.root().parents('body').length === 0) {
+        instance.cleanup();
+        delete $X._instanceCache[i];
+      }
+    }
+  };
 
-    return Xooie;
+  return Xooie;
 });
 
-require(['jquery', 'xooie/xooie'], function($, $X){
-    $(document).ready(function() {
-        $X($(this));
-    });
-});
+require(['jquery', 'xooie/xooie'], function ($, $X) {
+  'use strict';
+
+  $(document).ready(function () {
+    $X($(this));
+  });
+});