jquerypp-rails 1.0

data/vendor/assets/javascripts/lib/jquery.animate.js

@@ -0,0 +1,326 @@
+// Dependencies:
+//
+//    - jquery.animate.js
+//    - jquery.styles.js
+
+(function ($) {
+
+	// Overwrites `jQuery.fn.animate` to use CSS 3 animations if possible
+
+	var
+		// The global animation counter
+		animationNum = 0,
+		// The stylesheet for our animations
+		styleSheet = null,
+		// The animation cache
+		cache = [],
+		// Stores the browser properties like transition end event name and prefix
+		browser = null,
+		// Store the original $.fn.animate
+		oldanimate = $.fn.animate,
+
+		// Return the stylesheet, create it if it doesn't exists
+		getStyleSheet = function () {
+			if(!styleSheet) {
+				var style = document.createElement('style');
+				style.setAttribute("type", "text/css");
+				style.setAttribute("media", "screen");
+
+				document.getElementsByTagName('head')[0].appendChild(style);
+				if (!window.createPopup) { /* For Safari */
+					style.appendChild(document.createTextNode(''));
+				}
+
+				styleSheet = style.sheet;
+			}
+
+			return styleSheet;
+		},
+
+		//removes an animation rule from a sheet
+		removeAnimation = function (sheet, name) {
+			for (var j = sheet.cssRules.length - 1; j >= 0; j--) {
+				var rule = sheet.cssRules[j];
+				// 7 means the keyframe rule
+				if (rule.type === 7 && rule.name == name) {
+					sheet.deleteRule(j)
+					return;
+				}
+			}
+		},
+
+		// Returns whether the animation should be passed to the original $.fn.animate.
+		passThrough = function (props, ops) {
+			var nonElement = !(this[0] && this[0].nodeType),
+				isInline = !nonElement && $(this).css("display") === "inline" && $(this).css("float") === "none";
+
+			for (var name in props) {
+				// jQuery does something with these values
+				if (props[name] == 'show' || props[name] == 'hide' || props[name] == 'toggle'
+					// Arrays for individual easing
+					|| $.isArray(props[name])
+					// Negative values not handled the same
+					|| props[name] < 0
+					// unit-less value
+					|| name == 'zIndex' || name == 'z-index'
+					) {
+					return true;
+				}
+			}
+
+			return props.jquery === true || getBrowser() === null ||
+				// Animating empty properties
+				$.isEmptyObject(props) ||
+				// We can't do custom easing
+				ops.length == 4 || typeof ops[2] == 'string' ||
+				// Second parameter is an object - we can only handle primitives
+				$.isPlainObject(ops) ||
+				// Inline and non elements
+				isInline || nonElement;
+		},
+
+		// Gets a CSS number (with px added as the default unit if the value is a number)
+		cssValue = function(origName, value) {
+			if (typeof value === "number" && !$.cssNumber[ origName ]) {
+				return value += "px";
+			}
+			return value;
+		},
+
+		// Feature detection borrowed by http://modernizr.com/
+		getBrowser = function(){
+			if(!browser) {
+				var t,
+					el = document.createElement('fakeelement'),
+					transitions = {
+						'transition': {
+							transitionEnd : 'transitionEnd',
+							prefix : ''
+						},
+//						'OTransition': {
+//							transitionEnd : 'oTransitionEnd',
+//							prefix : '-o-'
+//						},
+//						'MSTransition': {
+//							transitionEnd : 'msTransitionEnd',
+//							prefix : '-ms-'
+//						},
+						'MozTransition': {
+							transitionEnd : 'animationend',
+							prefix : '-moz-'
+						},
+						'WebkitTransition': {
+							transitionEnd : 'webkitAnimationEnd',
+							prefix : '-webkit-'
+						}
+					}
+
+				for(t in transitions){
+					if( el.style[t] !== undefined ){
+						browser = transitions[t];
+					}
+				}
+			}
+			return browser;
+		},
+
+		// Properties that Firefox can't animate if set to 'auto':
+		// https://bugzilla.mozilla.org/show_bug.cgi?id=571344
+		// Provides a converter that returns the actual value
+		ffProps = {
+			top : function(el) {
+				return el.position().top;
+			},
+			left : function(el) {
+				return el.position().left;
+			},
+			width : function(el) {
+				return el.width();
+			},
+			height : function(el) {
+				return el.height();
+			},
+			fontSize : function(el) {
+				return '1em';
+			}
+		},
+
+		// Add browser specific prefix
+		addPrefix = function(properties) {
+			var result = {};
+			$.each(properties, function(name, value) {
+				result[getBrowser().prefix + name] = value;
+			});
+			return result;
+		},
+
+		// Returns the animation name for a given style. It either uses a cached
+		// version or adds it to the stylesheet, removing the oldest style if the
+		// cache has reached a certain size.
+		getAnimation = function(style) {
+			var sheet, name, last;
+
+			// Look up the cached style, set it to that name and reset age if found
+			// increment the age for any other animation
+			$.each(cache, function(i, animation) {
+				if(style === animation.style) {
+					name = animation.name;
+					animation.age = 0;
+				} else {
+					animation.age += 1;
+				}
+			});
+
+			if(!name) { // Add a new style
+				sheet = getStyleSheet();
+				name = "jquerypp_animation_" + (animationNum++);
+				// get the last sheet and insert this rule into it
+				sheet.insertRule("@" + getBrowser().prefix + "keyframes " + name + ' ' + style,
+					(sheet.cssRules && sheet.cssRules.length) || 0);
+				cache.push({
+					name : name,
+					style : style,
+					age : 0
+				});
+
+				// Sort the cache by age
+				cache.sort(function(first, second) {
+					return first.age - second.age;
+				});
+
+				// Remove the last (oldest) item from the cache if it has more than 20 items
+				if(cache.length > 20) {
+					last = cache.pop();
+					removeAnimation(sheet, last.name);
+				}
+			}
+
+			return name;
+		};
+
+	/**
+	 * @function $.fn.animate
+	 * @parent $.animate
+	 *
+	 * Animate CSS properties using native CSS animations, if possible.
+	 * Uses the original [$.fn.animate()](http://api.$.com/animate/) otherwise.
+	 *
+	 * @param {Object} props The CSS properties to animate
+	 * @param {Integer|String|Object} [speed=400] The animation duration in ms.
+	 * Will use $.fn.animate if a string or object is passed
+	 * @param {Function} [callback] A callback to execute once the animation is complete
+	 * @return {jQuery} The jQuery element
+	 */
+	$.fn.animate = function (props, speed, easing, callback) {
+		//default to normal animations if browser doesn't support them
+		if (passThrough.apply(this, arguments)) {
+			return oldanimate.apply(this, arguments);
+		}
+
+		var optall = jQuery.speed(speed, easing, callback);
+
+		// Add everything to the animation queue
+		this.queue(optall.queue, function(done) {
+			var
+				//current CSS values
+				current,
+				// The list of properties passed
+				properties = [],
+				to = "",
+				prop,
+				self = $(this),
+				duration = optall.duration,
+				//the animation keyframe name
+				animationName,
+				// The key used to store the animation hook
+				dataKey,
+				//the text for the keyframe
+				style = "{ from {",
+				// The animation end event handler.
+				// Will be called both on animation end and after calling .stop()
+				animationEnd = function (currentCSS, exec) {
+					self.css(currentCSS);
+					
+					self.css(addPrefix({
+						"animation-duration" : "",
+						"animation-name" : "",
+						"animation-fill-mode" : "",
+						"animation-play-state" : ""
+					}));
+
+					// Call the original callback
+					if (optall.old && exec) {
+						// Call success, pass the DOM element as the this reference
+						optall.old.call(self[0], true)
+					}
+
+					$.removeData(self, dataKey, true);
+				}
+
+			for(prop in props) {
+				properties.push(prop);
+			}
+
+			if(getBrowser().prefix === '-moz-') {
+				// Normalize 'auto' properties in FF
+				$.each(properties, function(i, prop) {
+					var converter = ffProps[$.camelCase(prop)];
+					if(converter && self.css(prop) == 'auto') {
+						self.css(prop, converter(self));
+					}
+				});
+			}
+
+			// Use $.styles
+			current = self.styles.apply(self, properties);
+			$.each(properties, function(i, cur) {
+				// Convert a camelcased property name
+				var name = cur.replace(/([A-Z]|^ms)/g, "-$1" ).toLowerCase();
+				style += name + " : " + cssValue(cur, current[cur]) + "; ";
+				to += name + " : " + cssValue(cur, props[cur]) + "; ";
+			});
+
+			style += "} to {" + to + " }}";
+
+			animationName = getAnimation(style);
+			dataKey = animationName + '.run';
+
+			// Add a hook which will be called when the animation stops
+			$._data(this, dataKey, {
+				stop : function(gotoEnd) {
+					// Pause the animation
+					self.css(addPrefix({
+						'animation-play-state' : 'paused'
+					}));
+					// Unbind the animation end handler
+					self.off(getBrowser().transitionEnd, animationEnd);
+					if(!gotoEnd) {
+						// We were told not to finish the animation
+						// Call animationEnd but set the CSS to the current computed style
+						animationEnd(self.styles.apply(self, properties), false);
+					} else {
+						// Finish animaion
+						animationEnd(props, true);
+					}
+				}
+			});
+
+			// set this element to point to that animation
+			self.css(addPrefix({
+				"animation-duration" : duration + "ms",
+				"animation-name" : animationName,
+				"animation-fill-mode": "forwards"
+			}));
+
+			// Attach the transition end event handler to run only once
+			self.one(getBrowser().transitionEnd, function() {
+				// Call animationEnd using the passed properties
+				animationEnd(props, true);
+				done();
+			});
+
+		});
+
+		return this;
+	};
+})(jQuery)

data/vendor/assets/javascripts/lib/jquery.compare.js

@@ -0,0 +1,75 @@
+//    - jquery.compare.js
+(function($){
+
+/**
+ * @function jQuery.fn.compare
+ * @parent jQuery.compare
+ *
+ * Compare two elements and return a bitmask as a number representing the following conditions:
+ *
+ * - `000000` -> __0__: Elements are identical
+ * - `000001` -> __1__: The nodes are in different documents (or one is outside of a document)
+ * - `000010` -> __2__: #bar precedes #foo
+ * - `000100` -> __4__: #foo precedes #bar
+ * - `001000` -> __8__: #bar contains #foo
+ * - `010000` -> __16__: #foo contains #bar
+ *
+ * You can check for any of these conditions using a bitwise AND:
+ *
+ *     if( $('#foo').compare($('#bar')) & 2 ) {
+ *       console.log("#bar precedes #foo")
+ *     }
+ *
+ * @param {HTMLElement|jQuery} element an element or jQuery collection to compare against.
+ * @return {Number} A number representing a bitmask deatiling how the elements are positioned from each other.
+ */
+
+// See http://ejohn.org/blog/comparing-document-position/
+jQuery.fn.compare = function(element){ //usually 
+	try{
+		// Firefox 3 throws an error with XUL - we can't use compare then
+		element = element.jquery ? element[0] : element;
+	}catch(e){
+		return null;
+	}
+
+	// make sure we aren't coming from XUL element
+	if (window.HTMLElement) {
+		var s = HTMLElement.prototype.toString.call(element)
+		if (s == '[xpconnect wrapped native prototype]' || s == '[object XULElement]' || s === '[object Window]') {
+			return null;
+		}
+	}
+
+	if(this[0].compareDocumentPosition){
+		// For browsers that support it, use compareDocumentPosition
+		// https://developer.mozilla.org/en/DOM/Node.compareDocumentPosition
+		return this[0].compareDocumentPosition(element);
+	}
+
+	// this[0] contains element
+	if(this[0] == document && element != document) return 8;
+
+	var number =
+			// this[0] contains element
+			(this[0] !== element && this[0].contains(element) && 16) +
+			// element contains this[0]
+			(this[0] != element && element.contains(this[0]) && 8),
+		docEl = document.documentElement;
+
+	// Use the sourceIndex
+	if(this[0].sourceIndex){
+		// this[0] precedes element
+		number += (this[0].sourceIndex < element.sourceIndex && 4)
+		// element precedes foo[0]
+		number += (this[0].sourceIndex > element.sourceIndex && 2)
+		// The nodes are in different documents
+		number += (this[0].ownerDocument !== element.ownerDocument ||
+			(this[0] != docEl && this[0].sourceIndex <= 0 ) ||
+			(element != docEl && element.sourceIndex <= 0 )) && 1
+	}
+
+	return number;
+}
+
+})(jQuery)

data/vendor/assets/javascripts/lib/jquery.cookie.js

@@ -0,0 +1,118 @@
+// Dependencies:
+//
+//    - jquery.cookie.js
+//    - jquery.lang.json.js
+
+(function() {
+    /**
+     * @function jQuery.cookie
+     * @parent jquerypp
+     * @plugin jquery/dom/cookie
+     * @author Klaus Hartl/klaus.hartl@stilbuero.de
+     *
+     * `jQuery.cookie(name, [value], [options])` lets you create, read and remove cookies. It is the
+     * [jQuery cookie plugin](https://github.com/carhartl/jquery-cookie) written by [Klaus Hartl](stilbuero.de)
+     * and dual licensed under the [MIT](http://www.opensource.org/licenses/mit-license.php)
+     * and [GPL](http://www.gnu.org/licenses/gpl.html) licenses.
+     *
+	 * ## Examples
+	 * 
+	 * Set the value of a cookie.
+	 *  
+	 *      $.cookie('the_cookie', 'the_value');
+	 * 
+	 * Create a cookie with all available options.
+	 *
+     *      $.cookie('the_cookie', 'the_value', {
+     *          expires: 7,
+     *          path: '/',
+     *          domain: 'jquery.com',
+     *          secure: true
+     *      });
+	 *
+	 * Create a session cookie.
+	 *
+     *      $.cookie('the_cookie', 'the_value');
+	 *
+	 * Delete a cookie by passing null as value. Keep in mind that you have to use the same path and domain
+	 * used when the cookie was set.
+	 *
+     *      $.cookie('the_cookie', null);
+	 *
+	 * Get the value of a cookie.
+     *
+	 *      $.cookie('the_cookie');
+     *
+     * @param {String} [name] The name of the cookie.
+     * @param {String} [value] The value of the cookie.
+     * @param {Object} [options] An object literal containing key/value pairs to provide optional cookie attributes. Values can be:
+     *
+     * - `expires` - Either an integer specifying the expiration date from now on in days or a Date object. If a negative value is specified (e.g. a date in the past), the cookie will be deleted. If set to null or omitted, the cookie will be a session cookie and will not be retained when the the browser exits.
+     * - `domain` - The domain name
+     * - `path` - The value of the path atribute of the cookie (default: path of page that created the cookie).
+     * - `secure` - If true, the secure attribute of the cookie will be set and the cookie transmission will require a secure protocol (like HTTPS).
+     *
+     * @return {String} the value of the cookie or {undefined} when setting the cookie.
+     */
+    jQuery.cookie = function(name, value, options) {
+        if (typeof value != 'undefined') {
+            // name and value given, set cookie
+            options = options ||
+            {};
+            if (value === null) {
+                value = '';
+                options.expires = -1;
+            }
+	        // convert value to JSON string
+            if (typeof value == 'object' && jQuery.toJSON) {
+                value = jQuery.toJSON(value);
+            }
+            var expires = '';
+	        // Set expiry
+            if (options.expires && (typeof options.expires == 'number' || options.expires.toUTCString)) {
+                var date;
+                if (typeof options.expires == 'number') {
+                    date = new Date();
+                    date.setTime(date.getTime() + (options.expires * 24 * 60 * 60 * 1000));
+                }
+                else {
+                    date = options.expires;
+                }
+                expires = '; expires=' + date.toUTCString(); // use expires attribute, max-age is not supported by IE
+            }
+            // CAUTION: Needed to parenthesize options.path and options.domain
+            // in the following expressions, otherwise they evaluate to undefined
+            // in the packed version for some reason...
+            var path = options.path ? '; path=' + (options.path) : '';
+            var domain = options.domain ? '; domain=' + (options.domain) : '';
+            var secure = options.secure ? '; secure' : '';
+	        // Set the cookie name=value;expires=;path=;domain=;secure-
+            document.cookie = [name, '=', encodeURIComponent(value), expires, path, domain, secure].join('');
+        }
+        else { // only name given, get cookie
+            var cookieValue = null;
+            if (document.cookie && document.cookie != '') {
+                var cookies = document.cookie.split(';');
+                for (var i = 0; i < cookies.length; i++) {
+                    var cookie = jQuery.trim(cookies[i]);
+                    // Does this cookie string begin with the name we want?
+                    if (cookie.substring(0, name.length + 1) == (name + '=')) {
+	                    // Get the cookie value
+                        cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
+                        break;
+                    }
+                }
+            }
+	        // Parse JSON from the cookie into an object
+            if (jQuery.evalJSON && cookieValue && cookieValue.match(/^\s*\{/)) {
+                try {
+                    cookieValue = jQuery.evalJSON(cookieValue);
+                }
+                catch (e) {
+                }
+            }
+            return cookieValue;
+        }
+    };
+
+})(jQuery)