spiderfw 0.5.13 → 0.5.14

data/apps/core/components/public/js/jquery/jquery-ui-1.8.4/development-bundle/ui/jquery.ui.widget.js

@@ -0,0 +1,237 @@
+/*!
+ * jQuery UI Widget 1.8.4
+ *
+ * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Widget
+ */
+(function( $, undefined ) {
+
+var _remove = $.fn.remove;
+
+$.fn.remove = function( selector, keepData ) {
+	return this.each(function() {
+		if ( !keepData ) {
+			if ( !selector || $.filter( selector, [ this ] ).length ) {
+				$( "*", this ).add( [ this ] ).each(function() {
+					$( this ).triggerHandler( "remove" );
+				});
+			}
+		}
+		return _remove.call( $(this), selector, keepData );
+	});
+};
+
+$.widget = function( name, base, prototype ) {
+	var namespace = name.split( "." )[ 0 ],
+		fullName;
+	name = name.split( "." )[ 1 ];
+	fullName = namespace + "-" + name;
+
+	if ( !prototype ) {
+		prototype = base;
+		base = $.Widget;
+	}
+
+	// create selector for plugin
+	$.expr[ ":" ][ fullName ] = function( elem ) {
+		return !!$.data( elem, name );
+	};
+
+	$[ namespace ] = $[ namespace ] || {};
+	$[ namespace ][ name ] = function( options, element ) {
+		// allow instantiation without initializing for simple inheritance
+		if ( arguments.length ) {
+			this._createWidget( options, element );
+		}
+	};
+
+	var basePrototype = new base();
+	// we need to make the options hash a property directly on the new instance
+	// otherwise we'll modify the options hash on the prototype that we're
+	// inheriting from
+//	$.each( basePrototype, function( key, val ) {
+//		if ( $.isPlainObject(val) ) {
+//			basePrototype[ key ] = $.extend( {}, val );
+//		}
+//	});
+	basePrototype.options = $.extend( true, {}, basePrototype.options );
+	$[ namespace ][ name ].prototype = $.extend( true, basePrototype, {
+		namespace: namespace,
+		widgetName: name,
+		widgetEventPrefix: $[ namespace ][ name ].prototype.widgetEventPrefix || name,
+		widgetBaseClass: fullName
+	}, prototype );
+
+	$.widget.bridge( name, $[ namespace ][ name ] );
+};
+
+$.widget.bridge = function( name, object ) {
+	$.fn[ name ] = function( options ) {
+		var isMethodCall = typeof options === "string",
+			args = Array.prototype.slice.call( arguments, 1 ),
+			returnValue = this;
+
+		// allow multiple hashes to be passed on init
+		options = !isMethodCall && args.length ?
+			$.extend.apply( null, [ true, options ].concat(args) ) :
+			options;
+
+		// prevent calls to internal methods
+		if ( isMethodCall && options.substring( 0, 1 ) === "_" ) {
+			return returnValue;
+		}
+
+		if ( isMethodCall ) {
+			this.each(function() {
+				var instance = $.data( this, name ),
+					methodValue = instance && $.isFunction( instance[options] ) ?
+						instance[ options ].apply( instance, args ) :
+						instance;
+				if ( methodValue !== instance && methodValue !== undefined ) {
+					returnValue = methodValue;
+					return false;
+				}
+			});
+		} else {
+			this.each(function() {
+				var instance = $.data( this, name );
+				if ( instance ) {
+					if ( options ) {
+						instance.option( options );
+					}
+					instance._init();
+				} else {
+					$.data( this, name, new object( options, this ) );
+				}
+			});
+		}
+
+		return returnValue;
+	};
+};
+
+$.Widget = function( options, element ) {
+	// allow instantiation without initializing for simple inheritance
+	if ( arguments.length ) {
+		this._createWidget( options, element );
+	}
+};
+
+$.Widget.prototype = {
+	widgetName: "widget",
+	widgetEventPrefix: "",
+	options: {
+		disabled: false
+	},
+	_createWidget: function( options, element ) {
+		// $.widget.bridge stores the plugin instance, but we do it anyway
+		// so that it's stored even before the _create function runs
+		$.data( element, this.widgetName, this );
+		this.element = $( element );
+		this.options = $.extend( true, {},
+			this.options,
+			$.metadata && $.metadata.get( element )[ this.widgetName ],
+			options );
+
+		var self = this;
+		this.element.bind( "remove." + this.widgetName, function() {
+			self.destroy();
+		});
+
+		this._create();
+		this._init();
+	},
+	_create: function() {},
+	_init: function() {},
+
+	destroy: function() {
+		this.element
+			.unbind( "." + this.widgetName )
+			.removeData( this.widgetName );
+		this.widget()
+			.unbind( "." + this.widgetName )
+			.removeAttr( "aria-disabled" )
+			.removeClass(
+				this.widgetBaseClass + "-disabled " +
+				"ui-state-disabled" );
+	},
+
+	widget: function() {
+		return this.element;
+	},
+
+	option: function( key, value ) {
+		var options = key,
+			self = this;
+
+		if ( arguments.length === 0 ) {
+			// don't return a reference to the internal hash
+			return $.extend( {}, self.options );
+		}
+
+		if  (typeof key === "string" ) {
+			if ( value === undefined ) {
+				return this.options[ key ];
+			}
+			options = {};
+			options[ key ] = value;
+		}
+
+		$.each( options, function( key, value ) {
+			self._setOption( key, value );
+		});
+
+		return self;
+	},
+	_setOption: function( key, value ) {
+		this.options[ key ] = value;
+
+		if ( key === "disabled" ) {
+			this.widget()
+				[ value ? "addClass" : "removeClass"](
+					this.widgetBaseClass + "-disabled" + " " +
+					"ui-state-disabled" )
+				.attr( "aria-disabled", value );
+		}
+
+		return this;
+	},
+
+	enable: function() {
+		return this._setOption( "disabled", false );
+	},
+	disable: function() {
+		return this._setOption( "disabled", true );
+	},
+
+	_trigger: function( type, event, data ) {
+		var callback = this.options[ type ];
+
+		event = $.Event( event );
+		event.type = ( type === this.widgetEventPrefix ?
+			type :
+			this.widgetEventPrefix + type ).toLowerCase();
+		data = data || {};
+
+		// copy original event properties over to the new event
+		// this would happen if we could call $.event.fix instead of $.Event
+		// but we don't have a way to force an event to be fixed multiple times
+		if ( event.originalEvent ) {
+			for ( var i = $.event.props.length, prop; i; ) {
+				prop = $.event.props[ --i ];
+				event[ prop ] = event.originalEvent[ prop ];
+			}
+		}
+
+		this.element.trigger( event, data );
+
+		return !( $.isFunction(callback) &&
+			callback.call( this.element[0], event, data ) === false ||
+			event.isDefaultPrevented() );
+	}
+};
+
+})( jQuery );

data/apps/core/components/public/js/jquery/jquery-ui-1.8.4/development-bundle/version.txt

@@ -0,0 +1 @@
+1.8.4

data/apps/core/components/public/js/jquery/patches/jquery-ui/jquery.ui.autocomplete-001.patch

@@ -0,0 +1,17 @@
+--- old/development-bundle/ui/jquery.ui.autocomplete.js
++++ new/development-bundle/ui/jquery.ui.autocomplete.js
+@@ -70,7 +70,13 @@
+ 					//passthrough - ENTER and TAB both select the current element
+ 				case keyCode.TAB:
+ 					if ( !self.menu.active ) {
+-						return;
++					    if (!self.menu.element.is( ":visible" )) return;
++					    var firstItem = self.menu.element.children().eq(0);
++					    if (firstItem){
++					        self.menu.activate(event, firstItem);
++					        return false;
++					    } 
++                        else return;
+ 					}
+ 					self.menu.select( event );
+ 					break;

data/apps/core/components/public/js/jquery/plugins/jquery.datalink.js

@@ -0,0 +1,258 @@
+/*!
+ * jQuery Data Link Plugin
+ * http://github.com/jquery/jquery-datalink
+ *
+ * Copyright Software Freedom Conservancy, Inc.
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ */
+(function($){
+
+var oldcleandata = $.cleanData,
+	links = [],
+	fnSetters = {
+		val: "val",
+		html: "html",
+		text: "text"
+	};
+
+function setValue(target, field, value) {
+	if ( target.nodeType ) {
+	    if (field == 'val' && $(target).is('input[type=checkbox]')){
+	        if (value) $(target).attr('checked', true);
+            else $(target).attr('checked', false);
+	    }
+	    else{
+	        var setter = fnSetters[ field ] || "attr";
+    		$(target)[setter](value);
+	    }
+	} else {
+		$(target).data( field, value );
+	}
+}
+
+function getLinks(obj) {
+	var data = $.data( obj ),
+		cache,
+		fn = data._getLinks || (cache={s:[], t:[]}, data._getLinks = function() { return cache; });
+	return fn();
+}
+
+function bind(obj, wrapped, handler) {
+	wrapped.bind( obj.nodeType ? "change" : "changeData", handler );
+}
+function unbind(obj, wrapped, handler) {
+	wrapped.unbind( obj.nodeType ? "change" : "changeData", handler );
+}
+
+$.extend({
+	cleanData: function( elems ) {
+		for ( var j, i = 0, elem; (elem = elems[i]) != null; i++ ) {
+			// remove any links with this element as the source
+			// or the target.
+			var links = $.data( elem, "_getLinks" );
+			if ( links ) {
+				links = links();
+				// links this element is the source of
+				var self = $(elem);
+				$.each(links.s, function() {
+					unbind( elem, self, this.handler );
+					if ( this.handlerRev ) {
+						unbind( this.target, $(this.target), this.handlerRev );
+					}
+				});
+				// links this element is the target of
+				$.each(links.t, function() {
+					unbind( this.source, $(this.source), this.handler );
+					if ( this.handlerRev ) {
+						unbind( elem, self, this.handlerRev );
+					}
+				});
+				links.s = [];
+				links.t = [];
+			}
+		}
+		oldcleandata( elems );
+	},
+	convertFn: {
+		"!": function(value) {
+			return !value;
+		}
+	}
+});
+
+function getMapping(ev, changed, newvalue, map, source, target) {
+	var target = ev.target,
+		isSetData = ev.type === "changeData",
+		mappedName,
+		convert;
+		name;
+	if ( isSetData ) {
+		name = changed;
+		if ( ev.namespace ) {
+			name += "." + ev.namespace;
+		}
+	} else {
+		name = (target.name || target.id);
+	}
+	
+	if ( !map ) {
+		mappedName = name;
+	} else {
+		var m = map[ name ];
+		if ( !m ) {
+			return null;
+		}
+		mappedName = m.name;
+		convert = m.convert;
+		if ( typeof convert === "string" ) {
+			convert = $.convertFn[ convert ];
+		}
+	}
+	var val = null;
+	if (isSetData) val = newvalue;
+	else if (target && $(target).is('input[type=checkbox]')){
+        val = $(target).is(':checked');
+	}
+	else val = $(target).val();
+	return {
+		name: mappedName,
+		convert: convert,
+		value: val
+	};
+}
+
+$.extend($.fn, {
+	link: function(target, mapping) {
+		var self = this;
+		if ( !target ) {
+			return self;
+		}
+		function matchByName(name) {
+			var selector = "[name=" + name + "], [id=" + name +"]";
+			// include elements in this set that match as well a child matches
+			return self.filter(selector).add(self.find(selector));
+		}
+		if ( typeof target === "string" ) {
+			target = $( target, this.context || null )[ 0 ];
+		}
+		var hasTwoWay = !mapping,
+			map,
+			mapRev,
+			handler = function(ev, changed, newvalue) {
+				// a dom element change event occurred, update the target
+				var m = getMapping( ev, changed, newvalue, map );
+				if ( m ) {
+					var name = m.name,
+						value = m.value,
+						convert = m.convert;
+					if ( convert ) {
+						value = convert( value, ev.target, target );
+					}
+					if ( value !== undefined ) {
+						setValue( target, name, value );
+					}
+				}
+			},
+			handlerRev = function(ev, changed, newvalue) {
+				// a change or changeData event occurred on the target,
+				// update the corresponding source elements
+				var m = getMapping( ev, changed, newvalue, mapRev );
+				if ( m ) {
+					var name = m.name,
+						value = m.value,
+						convert = m.convert;
+					// find elements within the original selector
+					// that have the same name or id as the field that updated
+					matchByName(name).each(function() {
+						newvalue = value;
+						if ( convert ) {
+							newvalue = convert( newvalue, target, this );
+						}
+						if ( newvalue !== undefined ) {
+							setValue( this, "val", newvalue );
+						}
+					});
+				}
+				
+			};
+		if ( mapping ) {
+			$.each(mapping, function(n, v) {
+				var name = v,
+					convert,
+					convertBack,
+					twoWay;
+				if ( $.isPlainObject( v ) ) {
+					name = v.name || n;
+					convert = v.convert;
+					convertBack = v.convertBack;
+					twoWay = v.twoWay !== false;
+					hasTwoWay |= twoWay;
+				} else {
+					hasTwoWay = twoWay = true;
+				}
+				if ( twoWay ) {
+					mapRev = mapRev || {};
+					mapRev[ n ] = {
+						name: name,
+						convert: convertBack
+					};
+				}
+				map = map || {};
+				map[ name ] = { name: n, convert: convert, twoWay: twoWay };
+			});
+		}
+
+		// associate the link with each source and target so it can be
+		// removed automaticaly when _either_ side is removed.
+		self.each(function() {
+			bind( this, $(this), handler );
+			var link = {
+				handler: handler,
+				handlerRev: hasTwoWay ? handlerRev : null,
+				target: target,
+				source: this
+			};
+			getLinks( this ).s.push( link );
+			if ( target.nodeType ) {
+				getLinks( target ).t.push( link );
+			}
+		});
+		if ( hasTwoWay ) {
+			bind( target, $(target), handlerRev );
+		}
+		for (var n in target){
+		    if (!$.isFunction(target[n])){
+                handlerRev({type: 'changeData'}, n, target[n]);
+		    }
+		}
+		return self;
+	},
+	unlink: function(target) {
+		this.each(function() {
+			var self = $(this),
+				links = getLinks( this ).s;
+			for (var i = links.length-1; i >= 0; i--) {                
+				var link = links[ i ];
+				if ( link.target === target ) {
+					// unbind the handlers
+					//wrapped.unbind( obj.nodeType ? "change" : "changeData", handler );
+					unbind( this, self, link.handler );
+					if ( link.handlerRev ) {
+						unbind( link.target, $(link.target), link.handlerRev );
+					}
+					// remove from source links
+					links.splice( i, 1 );
+					// remove from target links
+					var targetLinks = getLinks( link.target ).t,
+						index = $.inArray( link, targetLinks );
+					if ( index !== -1 ) {
+						targetLinks.splice( index, 1 );
+					}
+				}
+			}
+		});
+	}
+});
+
+})(jQuery);

data/apps/core/components/public/js/jquery/plugins/jquery.json.js

@@ -0,0 +1,178 @@
+/*
+ * This document is licensed as free software under the terms of the
+ * MIT License: <a href="http://www.opensource.org/licenses/mit-license.php" title="http://www.opensource.org/licenses/mit-license.php">http://www.opensource.org/licenses/mit-license.php</a>
+ *
+ * Adapted by Rahul Singla.
+ *
+ * Brantley Harris wrote this plugin. It is based somewhat on the JSON.org 
+ * website's <a href="http://www.json.org/json2.js" title="http://www.json.org/json2.js">http://www.json.org/json2.js</a>, which proclaims:
+ * "NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.", a sentiment that
+ * I uphold.
+ *
+ * It is also influenced heavily by MochiKit's serializeJSON, which is 
+ * copyrighted 2005 by Bob Ippolito.
+ */
+
+/**
+ * jQuery.JSON.encode( json-serializble ) Converts the given argument into a
+ * JSON respresentation.
+ * 
+ * If an object has a "toJSON" function, that will be used to get the
+ * representation. Non-integer/string keys are skipped in the object, as are
+ * keys that point to a function.
+ * 
+ * json-serializble: The *thing* to be converted.
+ */
+jQuery.JSON = {
+	encode: function(o) {
+		if (typeof (JSON) == 'object' && JSON.stringify)
+			return JSON.stringify(o);
+
+		var type = typeof (o);
+
+		if (o === null)
+			return "null";
+
+		if (type == "undefined")
+			return undefined;
+
+		if (type == "number" || type == "boolean")
+			return o + "";
+
+		if (type == "string")
+			return this.quoteString(o);
+
+		if (type == 'object') {
+			if (typeof o.toJSON == "function")
+				return this.encode(o.toJSON());
+
+			if (o.constructor === Date) {
+				var month = o.getUTCMonth() + 1;
+				if (month < 10)
+					month = '0' + month;
+
+				var day = o.getUTCDate();
+				if (day < 10)
+					day = '0' + day;
+
+				var year = o.getUTCFullYear();
+
+				var hours = o.getUTCHours();
+				if (hours < 10)
+					hours = '0' + hours;
+
+				var minutes = o.getUTCMinutes();
+				if (minutes < 10)
+					minutes = '0' + minutes;
+
+				var seconds = o.getUTCSeconds();
+				if (seconds < 10)
+					seconds = '0' + seconds;
+
+				var milli = o.getUTCMilliseconds();
+				if (milli < 100)
+					milli = '0' + milli;
+				if (milli < 10)
+					milli = '0' + milli;
+
+				return '"' + year + '-' + month + '-' + day + 'T' + hours + ':'
+						+ minutes + ':' + seconds + '.' + milli + 'Z"';
+			}
+
+			if (o.constructor === Array) {
+				var ret = [];
+				for ( var i = 0; i < o.length; i++)
+					ret.push(this.encode(o[i]) || "null");
+
+				return "[" + ret.join(",") + "]";
+			}
+
+			var pairs = [];
+			for ( var k in o) {
+				var name;
+				var type = typeof k;
+
+				if (type == "number")
+					name = '"' + k + '"';
+				else if (type == "string")
+					name = this.quoteString(k);
+				else
+					continue; // skip non-string or number keys
+
+				if (typeof o[k] == "function")
+					continue; // skip pairs where the value is a function.
+
+				var val = this.encode(o[k]);
+
+				pairs.push(name + ":" + val);
+			}
+
+			return "{" + pairs.join(", ") + "}";
+		}
+	},
+
+	/**
+	 * jQuery.JSON.decode(src) Evaluates a given piece of json source.
+	 */
+	decode: function(src) {
+		if (typeof (JSON) == 'object' && JSON.parse)
+			return JSON.parse(src);
+		return eval("(" + src + ")");
+	},
+
+	/**
+	 * jQuery.JSON.decodeSecure(src) Evals JSON in a way that is *more* secure.
+	 */
+	decodeSecure: function(src) {
+		if (typeof (JSON) == 'object' && JSON.parse)
+			return JSON.parse(src);
+
+		var filtered = src;
+		filtered = filtered.replace(/\\["\\\/bfnrtu]/g, '@');
+		filtered = filtered
+				.replace(
+						/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
+						']');
+		filtered = filtered.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
+
+		if (/^[\],:{}\s]*$/.test(filtered))
+			return eval("(" + src + ")");
+		else
+			throw new SyntaxError("Error parsing JSON, source is not valid.");
+	},
+
+	/**
+	 * jQuery.JSON.quoteString(string) Returns a string-repr of a string, escaping
+	 * quotes intelligently. Mostly a support function for JSON.encode.
+	 * 
+	 * Examples: >>> jQuery.JSON.quoteString("apple") "apple"
+	 * 
+	 * >>> jQuery.JSON.quoteString('"Where are we going?", she asked.') "\"Where
+	 * are we going?\", she asked."
+	 */
+	quoteString: function(string) {
+		if (string.match(this._escapeable)) {
+			return '"' + string.replace(this._escapeable, function(a) {
+				var c = this._meta[a];
+				if (typeof c === 'string')
+					return c;
+				c = a.charCodeAt();
+				return '\\u00' + Math.floor(c / 16).toString(16)
+						+ (c % 16).toString(16);
+			}) + '"';
+		}
+		return '"' + string + '"';
+	},
+
+	_escapeable: /["\\\x00-\x1f\x7f-\x9f]/g,
+
+	_meta: {
+		'\b': '\\b',
+		'\t': '\\t',
+		'\n': '\\n',
+		'\f': '\\f',
+		'\r': '\\r',
+		'"': '\\"',
+		'\\': '\\\\'
+	}
+}