dojo-rails 0.9.8 → 0.9.9

data/vendor/assets/javascripts/dojo/_base/NodeList.js

@@ -0,0 +1,24 @@
+/*
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
+	Available via Academic Free License >= 2.1 OR the modified BSD license.
+	see: http://dojotoolkit.org/license for details
+*/
+
+//>>built
+define("dojo/_base/NodeList",["./kernel","../query","./array","./html","../NodeList-dom"],function(_1,_2,_3){
+var _4=_2.NodeList;
+var _5=_4.prototype;
+_5.connect=_4._adaptAsForEach(function(){
+return _1.connect.apply(this,arguments);
+});
+_5.coords=_4._adaptAsMap(_1.coords);
+_4.events=["blur","focus","change","click","error","keydown","keypress","keyup","load","mousedown","mouseenter","mouseleave","mousemove","mouseout","mouseover","mouseup","submit"];
+_3.forEach(_4.events,function(_6){
+var _7="on"+_6;
+_5[_7]=function(a,b){
+return this.connect(_7,a,b);
+};
+});
+_1.NodeList=_4;
+return _1.NodeList;
+});

data/vendor/assets/javascripts/dojo/_base/NodeList.js.uncompressed.js

@@ -0,0 +1,100 @@
+define("dojo/_base/NodeList", ["./kernel", "../query", "./array", "./html", "../NodeList-dom"], function(dojo, query, array){
+  //  module:
+  //    dojo/_base/NodeList
+  //  summary:
+  //    This module defines dojo.NodeList.
+ 
+var NodeList = query.NodeList;
+
+	/*=====
+	dojo.extend(dojo.NodeList, {
+		connect: function(methodName, objOrFunc, funcName){
+			// summary:
+			//		attach event handlers to every item of the NodeList. Uses dojo.connect()
+			//		so event properties are normalized
+			// methodName: String
+			//		the name of the method to attach to. For DOM events, this should be
+			//		the lower-case name of the event
+			// objOrFunc: Object|Function|String
+			//		if 2 arguments are passed (methodName, objOrFunc), objOrFunc should
+			//		reference a function or be the name of the function in the global
+			//		namespace to attach. If 3 arguments are provided
+			//		(methodName, objOrFunc, funcName), objOrFunc must be the scope to
+			//		locate the bound function in
+			// funcName: String?
+			//		optional. A string naming the function in objOrFunc to bind to the
+			//		event. May also be a function reference.
+			// example:
+			//		add an onclick handler to every button on the page
+			//		|	dojo.query("div:nth-child(odd)").connect("onclick", function(e){
+			//		|		console.log("clicked!");
+			//		|	});
+			// example:
+			//		attach foo.bar() to every odd div's onmouseover
+			//		|	dojo.query("div:nth-child(odd)").connect("onmouseover", foo, "bar");
+		},
+		coords: function(){
+			// summary:
+			//		Deprecated: Use position() for border-box x/y/w/h
+			//		or marginBox() for margin-box w/h/l/t.
+			//		Returns the box objects of all elements in a node list as
+			//		an Array (*not* a NodeList). Acts like `dojo.coords`, though assumes
+			//		the node passed is each node in this list.
+
+			return dojo.map(this, dojo.coords); // Array
+		}
+	 });
+
+	 var NodeList = dojo.NodeList;
+	=====*/
+	var nlp = NodeList.prototype;
+
+	// don't bind early to dojo.connect since we no longer explicitly depend on it
+	nlp.connect = NodeList._adaptAsForEach(function(){
+		return dojo.connect.apply(this, arguments);
+	});
+	nlp.coords = NodeList._adaptAsMap(dojo.coords);
+
+	NodeList.events = [
+		// summary:
+		//		list of all DOM events used in NodeList
+		"blur", "focus", "change", "click", "error", "keydown", "keypress",
+		"keyup", "load", "mousedown", "mouseenter", "mouseleave", "mousemove",
+		"mouseout", "mouseover", "mouseup", "submit"
+	];
+
+	// FIXME: pseudo-doc the above automatically generated on-event functions
+
+	// syntactic sugar for DOM events
+	array.forEach(NodeList.events, function(evt){
+			var _oe = "on" + evt;
+			nlp[_oe] = function(a, b){
+				return this.connect(_oe, a, b);
+			};
+				// FIXME: should these events trigger publishes?
+				/*
+				return (a ? this.connect(_oe, a, b) :
+							this.forEach(function(n){
+								// FIXME:
+								//		listeners get buried by
+								//		addEventListener and can't be dug back
+								//		out to be triggered externally.
+								// see:
+								//		http://developer.mozilla.org/en/docs/DOM:element
+
+								console.log(n, evt, _oe);
+
+								// FIXME: need synthetic event support!
+								var _e = { target: n, faux: true, type: evt };
+								// dojo._event_listener._synthesizeEvent({}, { target: n, faux: true, type: evt });
+								try{ n[evt](_e); }catch(e){ console.log(e); }
+								try{ n[_oe](_e); }catch(e){ console.log(e); }
+							})
+				);
+				*/
+		}
+	);
+
+	dojo.NodeList = NodeList;
+	return dojo.NodeList;
+});

data/vendor/assets/javascripts/dojo/_base/array.js

@@ -0,0 +1,142 @@
+/*
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
+	Available via Academic Free License >= 2.1 OR the modified BSD license.
+	see: http://dojotoolkit.org/license for details
+*/
+
+//>>built
+define("dojo/_base/array",["./kernel","../has","./lang"],function(_1,_2,_3){
+var _4={},u,_5;
+function _6(){
+_4={};
+};
+function _7(fn){
+return _4[fn]=new Function("item","index","array",fn);
+};
+function _8(_9){
+var _a=!_9;
+return function(a,fn,o){
+var i=0,l=a&&a.length||0,_b;
+if(l&&typeof a=="string"){
+a=a.split("");
+}
+if(typeof fn=="string"){
+fn=_4[fn]||_7(fn);
+}
+if(o){
+for(;i<l;++i){
+_b=!fn.call(o,a[i],i,a);
+if(_9^_b){
+return !_b;
+}
+}
+}else{
+for(;i<l;++i){
+_b=!fn(a[i],i,a);
+if(_9^_b){
+return !_b;
+}
+}
+}
+return _a;
+};
+};
+function _c(up){
+var _d=1,_e=0,_f=0;
+if(!up){
+_d=_e=_f=-1;
+}
+return function(a,x,_10,_11){
+if(_11&&_d>0){
+return _5.lastIndexOf(a,x,_10);
+}
+var l=a&&a.length||0,end=up?l+_f:_e,i;
+if(_10===u){
+i=up?_e:l+_f;
+}else{
+if(_10<0){
+i=l+_10;
+if(i<0){
+i=_e;
+}
+}else{
+i=_10>=l?l+_f:_10;
+}
+}
+if(l&&typeof a=="string"){
+a=a.split("");
+}
+for(;i!=end;i+=_d){
+if(a[i]==x){
+return i;
+}
+}
+return -1;
+};
+};
+function _12(a,fn,o){
+var i=0,l=a&&a.length||0;
+if(l&&typeof a=="string"){
+a=a.split("");
+}
+if(typeof fn=="string"){
+fn=_4[fn]||_7(fn);
+}
+if(o){
+for(;i<l;++i){
+fn.call(o,a[i],i,a);
+}
+}else{
+for(;i<l;++i){
+fn(a[i],i,a);
+}
+}
+};
+function map(a,fn,o,Ctr){
+var i=0,l=a&&a.length||0,out=new (Ctr||Array)(l);
+if(l&&typeof a=="string"){
+a=a.split("");
+}
+if(typeof fn=="string"){
+fn=_4[fn]||_7(fn);
+}
+if(o){
+for(;i<l;++i){
+out[i]=fn.call(o,a[i],i,a);
+}
+}else{
+for(;i<l;++i){
+out[i]=fn(a[i],i,a);
+}
+}
+return out;
+};
+function _13(a,fn,o){
+var i=0,l=a&&a.length||0,out=[],_14;
+if(l&&typeof a=="string"){
+a=a.split("");
+}
+if(typeof fn=="string"){
+fn=_4[fn]||_7(fn);
+}
+if(o){
+for(;i<l;++i){
+_14=a[i];
+if(fn.call(o,_14,i,a)){
+out.push(_14);
+}
+}
+}else{
+for(;i<l;++i){
+_14=a[i];
+if(fn(_14,i,a)){
+out.push(_14);
+}
+}
+}
+return out;
+};
+_5={every:_8(false),some:_8(true),indexOf:_c(true),lastIndexOf:_c(false),forEach:_12,map:map,filter:_13,clearCache:_6};
+1&&_3.mixin(_1,_5);
+return _5;
+});

data/vendor/assets/javascripts/dojo/_base/array.js.uncompressed.js

@@ -0,0 +1,343 @@
+define("dojo/_base/array", ["./kernel", "../has", "./lang"], function(dojo, has, lang){
+	// module:
+	//		dojo/_base/array
+	// summary:
+	//		This module defines the Javascript v1.6 array extensions.
+
+	/*=====
+	dojo.indexOf = function(arr, value, fromIndex, findLast){
+		// summary:
+		//		locates the first index of the provided value in the
+		//		passed array. If the value is not found, -1 is returned.
+		// description:
+		//		This method corresponds to the JavaScript 1.6 Array.indexOf method, with one difference: when
+		//		run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript
+		//		1.6's indexOf skips the holes in the sparse array.
+		//		For details on this method, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
+		// arr: Array
+		// value: Object
+		// fromIndex: Integer?
+		// findLast: Boolean?
+		// returns: Number
+	};
+	dojo.lastIndexOf = function(arr, value, fromIndex){
+		// summary:
+		//		locates the last index of the provided value in the passed
+		//		array. If the value is not found, -1 is returned.
+		// description:
+		//		This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with one difference: when
+		//		run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript
+		//		1.6's lastIndexOf skips the holes in the sparse array.
+		//		For details on this method, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/lastIndexOf
+		//	arr: Array,
+		//	value: Object,
+		//	fromIndex: Integer?
+		//	returns: Number
+	};
+	dojo.forEach = function(arr, callback, thisObject){
+		//	summary:
+		//		for every item in arr, callback is invoked. Return values are ignored.
+		//		If you want to break out of the loop, consider using dojo.every() or dojo.some().
+		//		forEach does not allow breaking out of the loop over the items in arr.
+		//	arr:
+		//		the array to iterate over. If a string, operates on individual characters.
+		//	callback:
+		//		a function is invoked with three arguments: item, index, and array
+		//	thisObject:
+		//		may be used to scope the call to callback
+		//	description:
+		//		This function corresponds to the JavaScript 1.6 Array.forEach() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach
+		//	example:
+		//	| // log out all members of the array:
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		function(item){
+		//	|			console.log(item);
+		//	|		}
+		//	| );
+		//	example:
+		//	| // log out the members and their indexes
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		function(item, idx, arr){
+		//	|			console.log(item, "at index:", idx);
+		//	|		}
+		//	| );
+		//	example:
+		//	| // use a scoped object member as the callback
+		//	|
+		//	| var obj = {
+		//	|		prefix: "logged via obj.callback:",
+		//	|		callback: function(item){
+		//	|			console.log(this.prefix, item);
+		//	|		}
+		//	| };
+		//	|
+		//	| // specifying the scope function executes the callback in that scope
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		obj.callback,
+		//	|		obj
+		//	| );
+		//	|
+		//	| // alternately, we can accomplish the same thing with dojo.hitch()
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		dojo.hitch(obj, "callback")
+		//	| );
+		//	arr: Array|String
+		//	callback: Function|String
+		//	thisObject: Object?
+	};
+	dojo.every = function(arr, callback, thisObject){
+		// summary:
+		//		Determines whether or not every item in arr satisfies the
+		//		condition implemented by callback.
+		// arr: Array|String
+		//		the array to iterate on. If a string, operates on individual characters.
+		// callback: Function|String
+		//		a function is invoked with three arguments: item, index,
+		//		and array and returns true if the condition is met.
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Boolean
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
+		// example:
+		//	| // returns false
+		//	| dojo.every([1, 2, 3, 4], function(item){ return item>1; });
+		// example:
+		//	| // returns true
+		//	| dojo.every([1, 2, 3, 4], function(item){ return item>0; });
+	};
+	dojo.some = function(arr, callback, thisObject){
+		// summary:
+		//		Determines whether or not any item in arr satisfies the
+		//		condition implemented by callback.
+		// arr: Array|String
+		//		the array to iterate over. If a string, operates on individual characters.
+		// callback: Function|String
+		//		a function is invoked with three arguments: item, index,
+		//		and array and returns true if the condition is met.
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Boolean
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
+		// example:
+		//	| // is true
+		//	| dojo.some([1, 2, 3, 4], function(item){ return item>1; });
+		// example:
+		//	| // is false
+		//	| dojo.some([1, 2, 3, 4], function(item){ return item<1; });
+	};
+	dojo.map = function(arr, callback, thisObject){
+		// summary:
+		//		applies callback to each element of arr and returns
+		//		an Array with the results
+		// arr: Array|String
+		//		the array to iterate on. If a string, operates on
+		//		individual characters.
+		// callback: Function|String
+		//		a function is invoked with three arguments, (item, index,
+		//		array),	 and returns a value
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Array
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
+		// example:
+		//	| // returns [2, 3, 4, 5]
+		//	| dojo.map([1, 2, 3, 4], function(item){ return item+1 });
+	};
+	dojo.filter = function(arr, callback, thisObject){
+		// summary:
+		//		Returns a new Array with those items from arr that match the
+		//		condition implemented by callback.
+		// arr: Array
+		//		the array to iterate over.
+		// callback: Function|String
+		//		a function that is invoked with three arguments (item,
+		//		index, array). The return of this function is expected to
+		//		be a boolean which determines whether the passed-in item
+		//		will be included in the returned array.
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Array
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
+		// example:
+		//	| // returns [2, 3, 4]
+		//	| dojo.filter([1, 2, 3, 4], function(item){ return item>1; });
+	};
+	=====*/
+
+	// our old simple function builder stuff
+	var cache = {}, u, array; // the export object
+
+	function clearCache(){
+		cache = {};
+	}
+
+	function buildFn(fn){
+		return cache[fn] = new Function("item", "index", "array", fn); // Function
+	}
+	// magic snippet: if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+
+	// every & some
+
+	function everyOrSome(some){
+		var every = !some;
+		return function(a, fn, o){
+			var i = 0, l = a && a.length || 0, result;
+			if(l && typeof a == "string") a = a.split("");
+			if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+			if(o){
+				for(; i < l; ++i){
+					result = !fn.call(o, a[i], i, a);
+					if(some ^ result){
+						return !result;
+					}
+				}
+			}else{
+				for(; i < l; ++i){
+					result = !fn(a[i], i, a);
+					if(some ^ result){
+						return !result;
+					}
+				}
+			}
+			return every; // Boolean
+		}
+	}
+	// var every = everyOrSome(false), some = everyOrSome(true);
+
+	// indexOf, lastIndexOf
+
+	function index(up){
+		var delta = 1, lOver = 0, uOver = 0;
+		if(!up){
+			delta = lOver = uOver = -1;
+		}
+		return function(a, x, from, last){
+			if(last && delta > 0){
+				// TODO: why do we use a non-standard signature? why do we need "last"?
+				return array.lastIndexOf(a, x, from);
+			}
+			var l = a && a.length || 0, end = up ? l + uOver : lOver, i;
+			if(from === u){
+				i = up ? lOver : l + uOver;
+			}else{
+				if(from < 0){
+					i = l + from;
+					if(i < 0){
+						i = lOver;
+					}
+				}else{
+					i = from >= l ? l + uOver : from;
+				}
+			}
+			if(l && typeof a == "string") a = a.split("");
+			for(; i != end; i += delta){
+				if(a[i] == x){
+					return i; // Number
+				}
+			}
+			return -1; // Number
+		}
+	}
+	// var indexOf = index(true), lastIndexOf = index(false);
+
+	function forEach(a, fn, o){
+		var i = 0, l = a && a.length || 0;
+		if(l && typeof a == "string") a = a.split("");
+		if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+		if(o){
+			for(; i < l; ++i){
+				fn.call(o, a[i], i, a);
+			}
+		}else{
+			for(; i < l; ++i){
+				fn(a[i], i, a);
+			}
+		}
+	}
+
+	function map(a, fn, o, Ctr){
+		// TODO: why do we have a non-standard signature here? do we need "Ctr"?
+		var i = 0, l = a && a.length || 0, out = new (Ctr || Array)(l);
+		if(l && typeof a == "string") a = a.split("");
+		if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+		if(o){
+			for(; i < l; ++i){
+				out[i] = fn.call(o, a[i], i, a);
+			}
+		}else{
+			for(; i < l; ++i){
+				out[i] = fn(a[i], i, a);
+			}
+		}
+		return out; // Array
+	}
+
+	function filter(a, fn, o){
+		// TODO: do we need "Ctr" here like in map()?
+		var i = 0, l = a && a.length || 0, out = [], value;
+		if(l && typeof a == "string") a = a.split("");
+		if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+		if(o){
+			for(; i < l; ++i){
+				value = a[i];
+				if(fn.call(o, value, i, a)){
+					out.push(value);
+				}
+			}
+		}else{
+			for(; i < l; ++i){
+				value = a[i];
+				if(fn(value, i, a)){
+					out.push(value);
+				}
+			}
+		}
+		return out; // Array
+	}
+
+	array = {
+		every:       everyOrSome(false),
+		some:        everyOrSome(true),
+		indexOf:     index(true),
+		lastIndexOf: index(false),
+		forEach:     forEach,
+		map:         map,
+		filter:      filter,
+		clearCache:  clearCache
+	};
+
+	1 && lang.mixin(dojo, array);
+
+	/*===== return dojo.array; =====*/
+	return array;
+});