xooie 0.1.7 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 602799066fe9227b564b94b1b7d1ccc2c9c19761
-  data.tar.gz: c29216021a9316b37eef6620d51ef54405aba818
+  metadata.gz: 4ab042b8a8738d53a37ca8896d4cdc6a58240e40
+  data.tar.gz: 092d46a6f2abd0b7142c5d7325e2bcc5a86baafa
 SHA512:
-  metadata.gz: 4556350ac6fb0aa61340262440789340ada0065345eaca9658c27d0100269b53e21a9e7ecd89e0fd4ca44101179795788a5c1e60f659ac4d1f2f97c658fb4373
-  data.tar.gz: 1d5821b24eb0eb33575196f582dec64f2c5c6c1b056c05b7290f5669917220aee9e30b5afe52d2c428b0d3801e865587c735e9554466cbec44d57e34bca67795
+  metadata.gz: 072980e920a4abd117dbc89b6136d0baf1101c56bfe45021983afb0d5fdcd6b1bd46e9c9c0129acd184c591aed11b24150994ddba644783328b90d97a17b6eef
+  data.tar.gz: 9e1241ae13314e68ce0fb9b195f0924dee1120026dd5335428b08ad0e73b82e19b69db9e99c37c6d7037e92bcb04ffb161eee4c3ebf79c2d12ce2ca1595b8fdb

data/README.md

@@ -30,12 +30,6 @@ Xooie will work by just loading xooie.js on your page; all other files will be l
 
 Instantiation happens automatically when the page is loaded. All HTML elements tagged with the "data-widget-type" attribute will offer the associated Xooie widget functionality.
 
-1.x vs 0.1.x:
----
-v1.0 is our official release of Xooie. All new feature development & bug fixes occur on [master](https://github.com/Comcast/Xooie) & are released from a release_1_x branch (e.g. [release_1_1](https://github.com/Comcast/Xooie/tree/release_1_1)). So if you're just getting started with Xooie, be sure to grab the latest 1.x version.
-
-If you were already using a pre-1.0 release of Xooie, there is a [release_0_1_x branch](https://github.com/Comcast/Xooie/tree/release_0_1_x) that is updated with bug fixes only. Any 0.1.x release is from the pre-1.0 Xooie development work. 
-
 Documentation:
 ---
 Carousel

data/lib/xooie.rb

@@ -1,8 +1,6 @@
 module Xooie
   module Rails
-    if defined?(::Rails)
-      class Engine < ::Rails::Engine
-      end
+    class Engine < ::Rails::Engine
     end
   end
 end

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

@@ -14,63 +14,228 @@
 *   limitations under the License.
 */
 
-define('xooie/addons/base', ['jquery'], function($) {
-    var Base = function(name, constructor){
-        var defaultOptions, initEvent, className, wrapper;
-
-        defaultOptions = {};
-        initEvent = 'xooie-addon-init.' + name.toLowerCase();
-        className = 'has-' + name.toLowerCase() + '-addon';
-
-        wrapper = function(module) {
-            //Let's check to see if module is defined...
-            //TODO: intelligently check if module is an instance of the base ui class
-            if (typeof module === 'undefined') {
-                return false;
+/**
+ * class Xooie.Addon
+ *
+ * The base xooie addon module.  This module defines how addons function in relation to
+ * widgets, but contains no specific functionality.
+ **/
+define('xooie/addons/base', ['jquery', 'xooie/shared'], function($, shared) {
+/**
+ * Xooie.Addon@xooie-addon-init(event)
+ * - event (Event): A jQuery event object
+ *
+ * A jQuery special event triggered when the addon is successfully initialized.  Triggers on the `root` element
+ * of the adodn's widget.  Unlike [[Xooie.Widget@xooie-init]], this event only triggers when the addon is first instantiated.
+ **/
+
+/**
+ * new Xooie.Addon(widget)
+ * - widget (Widget): An instance of [[Xooie.Widget]].
+ *
+ * Instantiating a new Addon associates the addon with the widget passed into the constructor.  The addon is
+ * stored in the [[Xooie.Widget#addons]] collection.
+ **/
+    var Addon = function(widget) {
+        var self = this;
+
+        // Check to see if the module is defined:
+        if (typeof widget === 'undefined') {
+            return false;
+        }
+
+        // If there is already an instance of this addon instantiated for the module, return it:
+        if (widget.addons() && widget.addons().hasOwnProperty(this.name())) {
+            return widget.addons()[this.name()];
+        }
+
+        // Add this addon to the widget's addons collection:
+        widget.addons()[this.name()] = this;
+
+        widget.root().addClass(this.addonClass());
+
+        // Reference the widget:
+        this.widget(widget);
+
+        // Check to see if there are any additional constructors to call;
+        var initCheck = function(){
+            var i;
+
+            if (!self._extendCount || self._extendCount <= 0) {
+                self.widget().root().trigger(self.get('initEvent'));
+                self._extendCount = null;
+            } else {
+                setTimeout(initCheck, 0);
             }
+        };
 
-            //if we've already instantiated an instance of this addon for this module, return it
-            if (module.addons && typeof module.addons[name] !== 'undefined') {
-                return module.addons[name];
-            }
-
-            //module is the module we are extending.
-            this.module = module;
-
-            //track this addon on the parent module
-            this.module.addons[name] = this;
-
-            //We'll need to extend the module's base properties
-            this.options = $.extend({}, wrapper.getDefaultOptions(), this.module.options);
+        if (this._extendCount > 0) {
+            setTimeout(initCheck, 0);
+        } else {
+            initCheck();
+        }
+    };
 
-            this.module.root.addClass(className);
+/**
+ * Xooie.Addon.defineReadOnly(name, defaultValue)
+ * - name (String): The name of the property to define as a read-only property.
+ * - defaultValue (Object): An optional default value.
+ *
+ * See [[Xooie.shared.defineReadOnly]].
+ **/
+    Addon.defineReadOnly = function(name, defaultValue){
+        shared.defineReadOnly(this, name, defaultValue);
+    };
 
-            constructor.apply(this, arguments);
+/**
+ * Xooie.Addon.defineWriteOnly(name)
+ * - name (String): The name of the property to define as a write-only property
+ *
+ * See [[Xooie.shared.defineWriteOnly]].
+ **/
+    Addon.defineWriteOnly = function(name){
+        shared.defineWriteOnly(this, name);
+    };
 
-            this.module.root.trigger(initEvent);
+/**
+ * Xooie.Widget.define(name[, defaultValue])
+ * - name (String): The name of the property to define.
+ * - defaultValue: An optional default value.
+ *
+ * A method that defines a property as both readable and writable.  In reality it calls both [[Xooie.Addon.defineReadOnly]]
+ * and [[Xooie.Addon.defineWriteOnly]].
+ **/
+    Addon.define = function(name, defaultValue){
+        this.defineReadOnly(name, defaultValue);
+        this.defineWriteOnly(name);
+    };
 
-        };
+/**
+ * Xooie.Addon.extend(constr) -> Addon
+ * - constr (Function): The constructor for the new [[Xooie.Addon]] class.
+ *
+ * See [[Xooie.shared.extend]].
+ **/
+    Addon.extend = function(constr){
+        return shared.extend(constr, this);
+    };
 
-        wrapper.prototype.cleanup = function() {
-            this.module.root.removeClass(className);
-        };
+/** internal
+ * Xooie.Addon#_definedProps -> Array
+ *
+ * Same as [[Xooie.Widget#_definedProps]].
+ **/
+    Addon.prototype._definedProps = [];
+
+/** internal
+ * Xooie.Addon#_extendCount -> Integer | null
+ *
+ * Same as [[Xooie.Widget#_extendCount]].
+ **/
+    Addon.prototype._extendCount = null;
+
+/** internal
+ * Xooie.Addon#_widget -> Widget
+ *
+ * The widget for which this addon was instantiated.
+ **/
+/**
+ * Xooie.Addon#widget([value]) -> Widget
+ * - value: an optional value to be set.
+ *
+ * The method for setting or getting [[Xooie.Addon#_widget]].  Returns the current value of
+ * [[Xooie.Addon#_widget]] if no value is passed or sets the value.
+ **/
+    Addon.define('widget');
+
+/** internal
+ * Xooie.Addon#_name -> String
+ *
+ * The name of the addon.
+ **/
+/**
+ * Xooie.Addon#name([value]) -> String
+ * - value: an optional value to be set.
+ *
+ * The method for setting or getting [[Xooie.Addon#_name]].  Returns the current value of
+ * [[Xooie.Addon#_name]] if no value is passed or sets the value.
+ **/
+    Addon.define('name', 'addon');
+
+/** internal, read-only
+ * Xooie.Addon#_initEvent -> String
+ *
+ * The name of the event triggered when the addon is instantiated.
+ **/
+/** read-only
+ * Xooie.Addon#initEvent() -> String
+ *
+ * The method for getting [[Xooie.Addon#_initEvent]].
+ **/
+    Addon.defineReadOnly('initEvent', 'xooie-addon-init');
+
+/** internal, read-only
+ * Xooie.Addon#_addonClass -> String
+ *
+ * The class added to the widget root indicating that this addon has been instantiated.
+ **/
+/** read-only
+ * Xooie.Addon#addonClass() -> String
+ *
+ * The method for getting [[Xooie.Addon#_addonClass]].
+ **/
+    Addon.defineReadOnly('addonClass', 'has-addon');
+
+/**
+ * Xooie.Addon#get(name) -> object
+ * - name (String): The name of the property to be retrieved.
+ *
+ * See [[Xooie.shared.get]].
+ **/
+    Addon.prototype.get = function(name) {
+        return shared.get(this, name);
+    };
 
-        wrapper.prototype.cleanup = function() {
-            this.module.root.removeClass(className);
-        };
+/**
+ * Xooie.Addon#set(name, value)
+ * - name (String): The name of the property to be set.
+ * - value: The value of the property to be set.
+ *
+ * See [[Xooie.shared.set]].
+ **/
+    Addon.prototype.set = function(name, value) {
+        return shared.set(this, name, value);
+    };
 
-        wrapper.getDefaultOptions = function(){
-            return defaultOptions;
-        };
+/**
+ * Xooie.Addon#cleanup()
+ *
+ * Removes the `addonClass` from the `root` of the associated `widget` and prepares this widget to be
+ * garbage collected.
+ **/
+    Addon.prototype.cleanup = function() {
+        this.widget().root().removeClass(this.addonClass());
+    };
 
-        wrapper.setDefaultOptions = function(options){
-            if (typeof options !== 'undefined') {
-                $.extend(defaultOptions, options);
-            }
-        };
+/** internal
+ * Xooie.Addon#_process_initEvent(initEvent) -> String
+ * - initEvent (String): The unmodified initEvent string.
+ *
+ * Adds the [[Xooie.Addon#name]] to the `initEvent`
+ **/
+    Addon.prototype._process_initEvent = function(initEvent) {
+        return this.name() === 'addon' ? initEvent : initEvent + '.' + this.name();
+    };
 
-        return wrapper;
+/** internal
+ * Xooie.Addon#_process_addonClass(className) -> String
+ * - className (String): The unmodified className string.
+ *
+ * Adds the [[Xooie.Addon#name]] to the `addonClass`
+ **/
+    Addon.prototype._process_addonClass = function(addonClass) {
+        return this.name() === 'addon' ? addonClass : 'has-' + this.name() + '-addon';
     };
 
-    return Base;
+    return Addon;
 });

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

@@ -29,10 +29,7 @@ define('xooie/base', ['jquery', 'xooie', 'xooie/stylesheet'], function($, $X, St
     };
 
     var Base = function(name, constructor) {
-        var instances, defaultOptions, instanceCounter,
-            initEvent, refreshEvent,
-            instanceName, cssRules,
-            stylesInstance, className, Xooie;
+        var instances, defaultOptions, instanceCounter, initEvent, instanceName, cssRules, stylesInstance, className, Xooie;
 
         instances = [];
 

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

@@ -45,7 +45,7 @@ define('xooie/carousel', ['jquery', 'xooie/base'], function($, Base) {
         this.positionUpdaters = {
 
             "item": function(quantity, direction) {
-                var items = self.content.children(':visible'),
+                var items = self.content.children(),
                     bias, offset,
                     position = self.wrapper.scrollLeft(),
                     i;
@@ -73,7 +73,7 @@ define('xooie/carousel', ['jquery', 'xooie/base'], function($, Base) {
 
             "px": function(quantity, direction) {
                 var position;
-
+                
                 if (typeof direction === 'undefined') {
                     position = 0;
                     direction = 1;
@@ -199,7 +199,7 @@ define('xooie/carousel', ['jquery', 'xooie/base'], function($, Base) {
         //It is possible that images may load after the carousel has instantiated/
         //Also, this can be used for lazy-loading images
         //TODO: This can be problematic, since it is triggering update dimensions for each image load
-        this.content.find('img').first().on('load', this.updateDimensions.bind(this));
+        this.content.find('img').on('load', this.updateDimensions.bind(this));
 
         carouselElements = carouselElements.add(this.root);
     });
@@ -244,7 +244,7 @@ define('xooie/carousel', ['jquery', 'xooie/base'], function($, Base) {
     };
 
     Carousel.prototype.currentItem = function(bias) {
-        var i, items = this.content.children(':visible'),
+        var i, items = this.content.children(),
             position, itemWidth;
 
         if (typeof bias === 'undefined') {
@@ -366,7 +366,7 @@ define('xooie/carousel', ['jquery', 'xooie/base'], function($, Base) {
         if (this.isScrolling) {
             self.wrapper.stop(true,true);
         }
-
+        
         callback();
 
     };

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

@@ -17,22 +17,16 @@
 define('xooie/dialog', ['jquery', 'xooie/base'], function($, Base) {
 
     var Dialog = Base('dialog', function(){
-        var self = this,
-            contentId;
+        var self = this;
 
         this.id = Dialog._counter++;
 
-        contentId = 'modal-content-' + this.id;
-
         Dialog._instances[this.id] = this;
 
         this.root.attr('data-dialog-id', this.id);
 
-        this.root.find(this.options.contentSelector).attr('id', contentId);
-
         //add accessibility attributes
-        this.root.find(this.options.containerSelector).attr('role', 'dialog')
-                                                      .attr('aria-describedby', contentId);
+        this.root.find(this.options.containerSelector).attr('role', 'dialog');
 
         this.root.addClass('xooie-dialog');
 
@@ -52,7 +46,6 @@ define('xooie/dialog', ['jquery', 'xooie/base'], function($, Base) {
     Dialog.setDefaultOptions({
         closeButtonSelector: '[data-role="closeButton"]',
         containerSelector: '[data-role="container"]',
-        contentSelector: '[data-role="content"]',
 
         dialogActiveClass: 'is-dialog-active'
     });
@@ -83,8 +76,6 @@ define('xooie/dialog', ['jquery', 'xooie/base'], function($, Base) {
 
         Dialog._active = this;
 
-        this.getTabbable().first().focus();
-
         this.root.trigger('dialogActive');
     };
 
@@ -103,26 +94,6 @@ define('xooie/dialog', ['jquery', 'xooie/base'], function($, Base) {
         this.root.trigger('dialogInactive');
     };
 
-    // Loosely based on jQueryUI's tabbable selector logic
-    Dialog.prototype.getTabbable = function () {
-        return this.root.find(this.options.containerSelector).find('*').filter(function (i) {
-            var tag, tabindex, istabbable;
-
-            tag = this.nodeName.toLowerCase();
-            tabindex = parseInt($(this).attr('tabindex'), 10);
-
-            if (/input|select|textarea|button|object/.test(tag)) {
-                istabbable = !this.disabled && (isNaN(tabindex) || tabindex > -1);
-            } else if ('a' === tag || 'area' === tag) {
-                istabbable =  this.href || tabindex > -1;
-            } else {
-                istabbable = tabindex > -1;
-            }
-
-            return istabbable && !$(this)['area' === tag ? 'parents' : 'closest'](':hidden').length;
-        });
-    };
-
     Dialog._instances = [];
     Dialog._counter = 0;
     Dialog._active = null;

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

@@ -15,7 +15,7 @@
 */
 
 define('xooie/dropdown', ['jquery', 'xooie/base'], function($, Base) {
-
+    
    var parseWhich = function(which) {
         if (typeof which === 'string') {
             which = which.split(',');
@@ -83,10 +83,6 @@ define('xooie/dropdown', ['jquery', 'xooie/base'], function($, Base) {
 
                 $(this).attr('aria-selected', false);
                 self.getExpander(index).attr('aria-hidden', true);
-            },
-
-            forceCollapse: function(event, data) {
-                self.collapse(data.index, data);
             }
         }, this.options.dropdownHandleSelector);
 
@@ -154,12 +150,8 @@ define('xooie/dropdown', ['jquery', 'xooie/base'], function($, Base) {
         }
     };
 
-    Dropdown.prototype.getNamespacedTrigger = function(trigger, state){
-        return trigger + '.' + state + 'XooieDropdown';
-    };
-
     Dropdown.prototype.addHandlers = function(state, index){
-        var trigger, nsTrigger, handle, triggerData, countName;
+        var trigger, handle, triggerData, countName;
 
         triggerData = this.options.triggers[state];
 
@@ -174,14 +166,12 @@ define('xooie/dropdown', ['jquery', 'xooie/base'], function($, Base) {
 
             handle.data(countName, handle.data(countName) + 1 || 1);
 
-            nsTrigger = this.getNamespacedTrigger(trigger, state);
-
-            handle.on(nsTrigger, $.extend({delay: 0, index: index}, triggerData[trigger]), this.handlers[state]);
+            handle.on(trigger, $.extend({delay: 0, index: index}, triggerData[trigger]), this.handlers[state]);
         }
     };
 
     Dropdown.prototype.removeHandlers = function(state, index){
-        var trigger, nsTrigger, handle, triggerData, countName, eventCount;
+        var trigger, handle, triggerData, countName, eventCount;
 
         triggerData = this.options.triggers[state];
 
@@ -193,9 +183,7 @@ define('xooie/dropdown', ['jquery', 'xooie/base'], function($, Base) {
             eventCount = handle.data(countName) - 1;
 
             if (eventCount <= 0) {
-                nsTrigger = this.getNamespacedTrigger(trigger, state);
-
-                handle.unbind(nsTrigger);
+                handle.unbind(trigger, this.handlers[state]);
 
                 handle.data(countName, 0);
             } else {

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

@@ -0,0 +1,83 @@
+/*
+*   Copyright 2012 Comcast
+*
+*   Licensed under the Apache License, Version 2.0 (the "License");
+*   you may not use this file except in compliance with the License.
+*   You may obtain a copy of the License at
+*
+*       http://www.apache.org/licenses/LICENSE-2.0
+*
+*   Unless required by applicable law or agreed to in writing, software
+*   distributed under the License is distributed on an "AS IS" BASIS,
+*   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*   See the License for the specific language governing permissions and
+*   limitations under the License.
+*/
+
+define('xooie/event_handler', ['jquery', 'xooie/helpers'], function($, helpers) {
+
+  var EventHandler = function(namespace) {
+    this.namespace = namespace;
+
+    this.handlers = {};
+
+    this._callbacks = {};
+  };
+
+  function format(type, namespace) {
+    if (typeof namespace === 'undefined') {
+      return type;
+    } else {
+      return type + '.' + namespace;
+    }
+  }
+
+  EventHandler.prototype.add = function(type, method) {
+    var self = this,
+        formattedType, t;
+
+    if (helpers.isObject(type) && helpers.isUndefined(method)) {
+      for(t in type) {
+        if (helpers.isFunction(type[t])) {
+          this.add(t, type[t]);
+        }
+      }
+
+      return;
+    }
+
+    formattedType = format(type, this.namespace);
+
+    if (helpers.isUndefined(this.handlers[formattedType])) {
+      this.handlers[formattedType] = function(e) {
+        self.fire(e, this, arguments);
+      };
+    }
+
+    if (helpers.isUndefined(this._callbacks[type])) {
+      this._callbacks[type] = $.Callbacks('unique');
+    }
+
+    this._callbacks[type].add(method);
+  };
+
+  EventHandler.prototype.clear = function(type) {
+    delete(this.handlers[format(type, this.namespace)]);
+
+    if (!helpers.isUndefined(this._callbacks[type])) {
+      this._callbacks[type].empty();
+    }
+  };
+
+  EventHandler.prototype.fire = function(event, context, args) {
+    if (event.namespace && event.namespace !== this.namespace) {
+      return;
+    }
+
+    if (!helpers.isUndefined(this._callbacks[event.type])) {
+      this._callbacks[event.type].fireWith(context, args);
+    }
+  };
+
+  return EventHandler;
+});

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

@@ -0,0 +1,61 @@
+/*
+*   Copyright 2012 Comcast
+*
+*   Licensed under the Apache License, Version 2.0 (the "License");
+*   you may not use this file except in compliance with the License.
+*   You may obtain a copy of the License at
+*
+*       http://www.apache.org/licenses/LICENSE-2.0
+*
+*   Unless required by applicable law or agreed to in writing, software
+*   distributed under the License is distributed on an "AS IS" BASIS,
+*   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*   See the License for the specific language governing permissions and
+*   limitations under the License.
+*/
+
+/**
+ * class Xooie.helpers
+ *
+ * A collection of helper methods used by Xooie modules.
+ **/
+
+define('xooie/helpers', ['jquery'], function($){
+  var helpers = {};
+/**
+ * Xooie.helpers.toAry(str) -> Array
+ * - str (String | Array): The string to be converted to an array, or an array.
+ *
+ * Converts a string to an array, or returns the passed argument if it is already an array.  Used
+ * when parsing data attributes that can be either a space-delineated string or an array.
+ **/
+  helpers.toAry = function(str) {
+    if (typeof str === 'string') {
+      return str.split(/\s+/);
+    } else if (str instanceof Array) {
+      return str;
+    }
+  };
+
+  helpers.toInt = function(int) {
+    return parseInt(int, 10);
+  };
+
+  helpers.isArray = Array.isArray || function(ary) {
+    return Array.prototype.toString(ary) === '[object Array]';
+  };
+
+  helpers.isObject = function(obj) {
+    return Object.prototype.toString(obj) === '[object Object]';
+  };
+
+  helpers.isUndefined = function(obj) {
+    return obj === void 0;
+  };
+
+  helpers.isFunction = function(func) {
+    return typeof func === 'function';
+  };
+
+  return helpers;
+});