dojo-rails 0.9.8 → 0.9.9

data/vendor/assets/javascripts/dojo/NodeList-dom.js

@@ -0,0 +1,122 @@
+/*
+	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/NodeList-dom",["./_base/kernel","./query","./_base/array","./_base/lang","./dom-class","./dom-construct","./dom-geometry","./dom-attr","./dom-style"],function(_1,_2,_3,_4,_5,_6,_7,_8,_9){
+var _a=function(a){
+return a.length==1&&(typeof a[0]=="string");
+};
+var _b=function(_c){
+var p=_c.parentNode;
+if(p){
+p.removeChild(_c);
+}
+};
+var _d=_2.NodeList,_e=_d._adaptWithCondition,_f=_d._adaptAsForEach,aam=_d._adaptAsMap;
+function _10(_11){
+return function(_12,_13,_14){
+if(arguments.length==2){
+return _11[typeof _13=="string"?"get":"set"](_12,_13);
+}
+return _11.set(_12,_13,_14);
+};
+};
+_4.extend(_d,{_normalize:function(_15,_16){
+var _17=_15.parse===true;
+if(typeof _15.template=="string"){
+var _18=_15.templateFunc||(_1.string&&_1.string.substitute);
+_15=_18?_18(_15.template,_15):_15;
+}
+var _19=(typeof _15);
+if(_19=="string"||_19=="number"){
+_15=_6.toDom(_15,(_16&&_16.ownerDocument));
+if(_15.nodeType==11){
+_15=_4._toArray(_15.childNodes);
+}else{
+_15=[_15];
+}
+}else{
+if(!_4.isArrayLike(_15)){
+_15=[_15];
+}else{
+if(!_4.isArray(_15)){
+_15=_4._toArray(_15);
+}
+}
+}
+if(_17){
+_15._runParse=true;
+}
+return _15;
+},_cloneNode:function(_1a){
+return _1a.cloneNode(true);
+},_place:function(ary,_1b,_1c,_1d){
+if(_1b.nodeType!=1&&_1c=="only"){
+return;
+}
+var _1e=_1b,_1f;
+var _20=ary.length;
+for(var i=_20-1;i>=0;i--){
+var _21=(_1d?this._cloneNode(ary[i]):ary[i]);
+if(ary._runParse&&_1.parser&&_1.parser.parse){
+if(!_1f){
+_1f=_1e.ownerDocument.createElement("div");
+}
+_1f.appendChild(_21);
+_1.parser.parse(_1f);
+_21=_1f.firstChild;
+while(_1f.firstChild){
+_1f.removeChild(_1f.firstChild);
+}
+}
+if(i==_20-1){
+_6.place(_21,_1e,_1c);
+}else{
+_1e.parentNode.insertBefore(_21,_1e);
+}
+_1e=_21;
+}
+},attr:_e(_10(_8),_a),style:_e(_10(_9),_a),addClass:_f(_5.add),removeClass:_f(_5.remove),replaceClass:_f(_5.replace),toggleClass:_f(_5.toggle),empty:_f(_6.empty),removeAttr:_f(_8.remove),position:aam(_7.position),marginBox:aam(_7.getMarginBox),place:function(_22,_23){
+var _24=_2(_22)[0];
+return this.forEach(function(_25){
+_6.place(_25,_24,_23);
+});
+},orphan:function(_26){
+return (_26?_2._filterResult(this,_26):this).forEach(_b);
+},adopt:function(_27,_28){
+return _2(_27).place(this[0],_28)._stash(this);
+},query:function(_29){
+if(!_29){
+return this;
+}
+var ret=new _d;
+this.map(function(_2a){
+_2(_29,_2a).forEach(function(_2b){
+if(_2b!==undefined){
+ret.push(_2b);
+}
+});
+});
+return ret._stash(this);
+},filter:function(_2c){
+var a=arguments,_2d=this,_2e=0;
+if(typeof _2c=="string"){
+_2d=_2._filterResult(this,a[0]);
+if(a.length==1){
+return _2d._stash(this);
+}
+_2e=1;
+}
+return this._wrap(_3.filter(_2d,a[_2e],a[_2e+1]),this);
+},addContent:function(_2f,_30){
+_2f=this._normalize(_2f,this[0]);
+for(var i=0,_31;(_31=this[i]);i++){
+this._place(_2f,_31,_30,i>0);
+}
+return this;
+}});
+return _d;
+});

data/vendor/assets/javascripts/dojo/NodeList-dom.js.uncompressed.js

@@ -0,0 +1,454 @@
+define("dojo/NodeList-dom", ["./_base/kernel", "./query", "./_base/array", "./_base/lang", "./dom-class", "./dom-construct", "./dom-geometry", "./dom-attr", "./dom-style"], function(dojo, query, array, lang, domCls, domCtr, domGeom, domAttr, domStyle){
+	/*===== var NodeList = dojo.NodeList; =====*/
+	var magicGuard = function(a){
+		// summary:
+		//		the guard function for dojo.attr() and dojo.style()
+		return a.length == 1 && (typeof a[0] == "string"); // inline'd type check
+	};
+
+	var orphan = function(node){
+		// summary:
+		//		function to orphan nodes
+		var p = node.parentNode;
+		if(p){
+			p.removeChild(node);
+		}
+	};
+	// FIXME: should we move orphan() to dojo.html?
+
+	var NodeList = query.NodeList,
+		awc = NodeList._adaptWithCondition,
+		aafe = NodeList._adaptAsForEach,
+		aam = NodeList._adaptAsMap;
+
+	function getSet(module){
+		return function(node, name, value){
+			if(arguments.length == 2){
+				return module[typeof name == "string" ? "get" : "set"](node, name);
+			}
+			// setter
+			return module.set(node, name, value);
+		};
+	}
+
+	lang.extend(NodeList, {
+		_normalize: function(/*String||Element||Object||NodeList*/content, /*DOMNode?*/refNode){
+			// summary:
+			//		normalizes data to an array of items to insert.
+			// description:
+			//		If content is an object, it can have special properties "template" and
+			//		"parse". If "template" is defined, then the template value is run through
+			//		dojo.string.substitute (if dojo.string.substitute has been dojo.required elsewhere),
+			//		or if templateFunc is a function on the content, that function will be used to
+			//		transform the template into a final string to be used for for passing to dojo._toDom.
+			//		If content.parse is true, then it is remembered for later, for when the content
+			//		nodes are inserted into the DOM. At that point, the nodes will be parsed for widgets
+			//		(if dojo.parser has been dojo.required elsewhere).
+
+			//Wanted to just use a DocumentFragment, but for the array/NodeList
+			//case that meant using cloneNode, but we may not want that.
+			//Cloning should only happen if the node operations span
+			//multiple refNodes. Also, need a real array, not a NodeList from the
+			//DOM since the node movements could change those NodeLists.
+
+			var parse = content.parse === true;
+
+			//Do we have an object that needs to be run through a template?
+			if(typeof content.template == "string"){
+				var templateFunc = content.templateFunc || (dojo.string && dojo.string.substitute);
+				content = templateFunc ? templateFunc(content.template, content) : content;
+			}
+
+			var type = (typeof content);
+			if(type == "string" || type == "number"){
+				content = domCtr.toDom(content, (refNode && refNode.ownerDocument));
+				if(content.nodeType == 11){
+					//DocumentFragment. It cannot handle cloneNode calls, so pull out the children.
+					content = lang._toArray(content.childNodes);
+				}else{
+					content = [content];
+				}
+			}else if(!lang.isArrayLike(content)){
+				content = [content];
+			}else if(!lang.isArray(content)){
+				//To get to this point, content is array-like, but
+				//not an array, which likely means a DOM NodeList. Convert it now.
+				content = lang._toArray(content);
+			}
+
+			//Pass around the parse info
+			if(parse){
+				content._runParse = true;
+			}
+			return content; //Array
+		},
+
+		_cloneNode: function(/*DOMNode*/ node){
+			// summary:
+			//		private utility to clone a node. Not very interesting in the vanilla
+			//		dojo.NodeList case, but delegates could do interesting things like
+			//		clone event handlers if that is derivable from the node.
+			return node.cloneNode(true);
+		},
+
+		_place: function(/*Array*/ary, /*DOMNode*/refNode, /*String*/position, /*Boolean*/useClone){
+			// summary:
+			//		private utility to handle placing an array of nodes relative to another node.
+			// description:
+			//		Allows for cloning the nodes in the array, and for
+			//		optionally parsing widgets, if ary._runParse is true.
+
+			//Avoid a disallowed operation if trying to do an innerHTML on a non-element node.
+			if(refNode.nodeType != 1 && position == "only"){
+				return;
+			}
+			var rNode = refNode, tempNode;
+
+			//Always cycle backwards in case the array is really a
+			//DOM NodeList and the DOM operations take it out of the live collection.
+			var length = ary.length;
+			for(var i = length - 1; i >= 0; i--){
+				var node = (useClone ? this._cloneNode(ary[i]) : ary[i]);
+
+				//If need widget parsing, use a temp node, instead of waiting after inserting into
+				//real DOM because we need to start widget parsing at one node up from current node,
+				//which could cause some already parsed widgets to be parsed again.
+				if(ary._runParse && dojo.parser && dojo.parser.parse){
+					if(!tempNode){
+						tempNode = rNode.ownerDocument.createElement("div");
+					}
+					tempNode.appendChild(node);
+					dojo.parser.parse(tempNode);
+					node = tempNode.firstChild;
+					while(tempNode.firstChild){
+						tempNode.removeChild(tempNode.firstChild);
+					}
+				}
+
+				if(i == length - 1){
+					domCtr.place(node, rNode, position);
+				}else{
+					rNode.parentNode.insertBefore(node, rNode);
+				}
+				rNode = node;
+			}
+		},
+
+		/*=====
+		position: function(){
+			// summary:
+			//		Returns border-box objects (x/y/w/h) of all elements in a node list
+			//		as an Array (*not* a NodeList). Acts like `dojo.position`, though
+			//		assumes the node passed is each node in this list.
+
+			return dojo.map(this, dojo.position); // Array
+		},
+
+		attr: function(property, value){
+			// summary:
+			//		gets or sets the DOM attribute for every element in the
+			//		NodeList. See also `dojo.attr`
+			// property: String
+			//		the attribute to get/set
+			// value: String?
+			//		optional. The value to set the property to
+			// returns:
+			//		if no value is passed, the result is an array of attribute values
+			//		If a value is passed, the return is this NodeList
+			// example:
+			//		Make all nodes with a particular class focusable:
+			//	|	dojo.query(".focusable").attr("tabIndex", -1);
+			// example:
+			//		Disable a group of buttons:
+			//	|	dojo.query("button.group").attr("disabled", true);
+			// example:
+			//		innerHTML can be assigned or retrieved as well:
+			//	|	// get the innerHTML (as an array) for each list item
+			//	|	var ih = dojo.query("li.replaceable").attr("innerHTML");
+			return; // dojo.NodeList
+			return; // Array
+		},
+
+		style: function(property, value){
+			// summary:
+			//		gets or sets the CSS property for every element in the NodeList
+			// property: String
+			//		the CSS property to get/set, in JavaScript notation
+			//		("lineHieght" instead of "line-height")
+			// value: String?
+			//		optional. The value to set the property to
+			// returns:
+			//		if no value is passed, the result is an array of strings.
+			//		If a value is passed, the return is this NodeList
+			return; // dojo.NodeList
+			return; // Array
+		},
+
+		addClass: function(className){
+			// summary:
+			//		adds the specified class to every node in the list
+			// className: String|Array
+			//		A String class name to add, or several space-separated class names,
+			//		or an array of class names.
+			return; // dojo.NodeList
+		},
+
+		removeClass: function(className){
+			// summary:
+			//		removes the specified class from every node in the list
+			// className: String|Array?
+			//		An optional String class name to remove, or several space-separated
+			//		class names, or an array of class names. If omitted, all class names
+			//		will be deleted.
+			// returns:
+			//		dojo.NodeList, this list
+			return; // dojo.NodeList
+		},
+
+		toggleClass: function(className, condition){
+			// summary:
+			//		Adds a class to node if not present, or removes if present.
+			//		Pass a boolean condition if you want to explicitly add or remove.
+			// condition: Boolean?
+			//		If passed, true means to add the class, false means to remove.
+			// className: String
+			//		the CSS class to add
+			return; // dojo.NodeList
+		},
+
+		empty: function(){
+			// summary:
+			//		clears all content from each node in the list. Effectively
+			//		equivalent to removing all child nodes from every item in
+			//		the list.
+			return this.forEach("item.innerHTML='';"); // dojo.NodeList
+			// FIXME: should we be checking for and/or disposing of widgets below these nodes?
+		},
+		=====*/
+
+		// useful html methods
+		attr: awc(getSet(domAttr), magicGuard),
+		style: awc(getSet(domStyle), magicGuard),
+
+		addClass: aafe(domCls.add),
+		removeClass: aafe(domCls.remove),
+		replaceClass: aafe(domCls.replace),
+		toggleClass: aafe(domCls.toggle),
+
+		empty: aafe(domCtr.empty),
+		removeAttr: aafe(domAttr.remove),
+
+		position: aam(domGeom.position),
+		marginBox: aam(domGeom.getMarginBox),
+
+		// FIXME: connectPublisher()? connectRunOnce()?
+
+		/*
+		destroy: function(){
+			// summary:
+			//		destroys every item in the list.
+			this.forEach(d.destroy);
+			// FIXME: should we be checking for and/or disposing of widgets below these nodes?
+		},
+		*/
+
+		place: function(/*String||Node*/ queryOrNode, /*String*/ position){
+			// summary:
+			//		places elements of this node list relative to the first element matched
+			//		by queryOrNode. Returns the original NodeList. See: `dojo.place`
+			// queryOrNode:
+			//		may be a string representing any valid CSS3 selector or a DOM node.
+			//		In the selector case, only the first matching element will be used
+			//		for relative positioning.
+			// position:
+			//		can be one of:
+			//		|	"last" (default)
+			//		|	"first"
+			//		|	"before"
+			//		|	"after"
+			//		|	"only"
+			//		|	"replace"
+			//		or an offset in the childNodes property
+			var item = query(queryOrNode)[0];
+			return this.forEach(function(node){ domCtr.place(node, item, position); }); // dojo.NodeList
+		},
+
+		orphan: function(/*String?*/ filter){
+			// summary:
+			//		removes elements in this list that match the filter
+			//		from their parents and returns them as a new NodeList.
+			// filter:
+			//		CSS selector like ".foo" or "div > span"
+			// returns:
+			//		`dojo.NodeList` containing the orphaned elements
+			return (filter ? query._filterResult(this, filter) : this).forEach(orphan); // dojo.NodeList
+		},
+
+		adopt: function(/*String||Array||DomNode*/ queryOrListOrNode, /*String?*/ position){
+			// summary:
+			//		places any/all elements in queryOrListOrNode at a
+			//		position relative to the first element in this list.
+			//		Returns a dojo.NodeList of the adopted elements.
+			// queryOrListOrNode:
+			//		a DOM node or a query string or a query result.
+			//		Represents the nodes to be adopted relative to the
+			//		first element of this NodeList.
+			// position:
+			//		can be one of:
+			//		|	"last" (default)
+			//		|	"first"
+			//		|	"before"
+			//		|	"after"
+			//		|	"only"
+			//		|	"replace"
+			//		or an offset in the childNodes property
+			return query(queryOrListOrNode).place(this[0], position)._stash(this);	// dojo.NodeList
+		},
+
+		// FIXME: do we need this?
+		query: function(/*String*/ queryStr){
+			// summary:
+			//		Returns a new list whose members match the passed query,
+			//		assuming elements of the current NodeList as the root for
+			//		each search.
+			// example:
+			//		assume a DOM created by this markup:
+			//	|	<div id="foo">
+			//	|		<p>
+			//	|			bacon is tasty, <span>dontcha think?</span>
+			//	|		</p>
+			//	|	</div>
+			//	|	<div id="bar">
+			//	|		<p>great comedians may not be funny <span>in person</span></p>
+			//	|	</div>
+			//		If we are presented with the following definition for a NodeList:
+			//	|	var l = new dojo.NodeList(dojo.byId("foo"), dojo.byId("bar"));
+			//		it's possible to find all span elements under paragraphs
+			//		contained by these elements with this sub-query:
+			//	|	var spans = l.query("p span");
+
+			// FIXME: probably slow
+			if(!queryStr){ return this; }
+			var ret = new NodeList;
+			this.map(function(node){
+				// FIXME: why would we ever get undefined here?
+				query(queryStr, node).forEach(function(subNode){
+					if(subNode !== undefined){
+						ret.push(subNode);
+					}
+				});
+			});
+			return ret._stash(this);	// dojo.NodeList
+		},
+
+		filter: function(/*String|Function*/ filter){
+			// summary:
+			//		"masks" the built-in javascript filter() method (supported
+			//		in Dojo via `dojo.filter`) to support passing a simple
+			//		string filter in addition to supporting filtering function
+			//		objects.
+			// filter:
+			//		If a string, a CSS rule like ".thinger" or "div > span".
+			// example:
+			//		"regular" JS filter syntax as exposed in dojo.filter:
+			//		|	dojo.query("*").filter(function(item){
+			//		|		// highlight every paragraph
+			//		|		return (item.nodeName == "p");
+			//		|	}).style("backgroundColor", "yellow");
+			// example:
+			//		the same filtering using a CSS selector
+			//		|	dojo.query("*").filter("p").styles("backgroundColor", "yellow");
+
+			var a = arguments, items = this, start = 0;
+			if(typeof filter == "string"){ // inline'd type check
+				items = query._filterResult(this, a[0]);
+				if(a.length == 1){
+					// if we only got a string query, pass back the filtered results
+					return items._stash(this); // dojo.NodeList
+				}
+				// if we got a callback, run it over the filtered items
+				start = 1;
+			}
+			return this._wrap(array.filter(items, a[start], a[start + 1]), this);	// dojo.NodeList
+		},
+
+		/*
+		// FIXME: should this be "copyTo" and include parenting info?
+		clone: function(){
+			// summary:
+			//		creates node clones of each element of this list
+			//		and returns a new list containing the clones
+		},
+		*/
+
+		addContent: function(/*String||DomNode||Object||dojo.NodeList*/ content, /*String||Integer?*/ position){
+			// summary:
+			//		add a node, NodeList or some HTML as a string to every item in the
+			//		list.  Returns the original list.
+			// description:
+			//		a copy of the HTML content is added to each item in the
+			//		list, with an optional position argument. If no position
+			//		argument is provided, the content is appended to the end of
+			//		each item.
+			// content:
+			//		DOM node, HTML in string format, a NodeList or an Object. If a DOM node or
+			//		NodeList, the content will be cloned if the current NodeList has more than one
+			//		element. Only the DOM nodes are cloned, no event handlers. If it is an Object,
+			//		it should be an object with at "template" String property that has the HTML string
+			//		to insert. If dojo.string has already been dojo.required, then dojo.string.substitute
+			//		will be used on the "template" to generate the final HTML string. Other allowed
+			//		properties on the object are: "parse" if the HTML
+			//		string should be parsed for widgets (dojo.require("dojo.parser") to get that
+			//		option to work), and "templateFunc" if a template function besides dojo.string.substitute
+			//		should be used to transform the "template".
+			// position:
+			//		can be one of:
+			//		|	"last"||"end" (default)
+			//		|	"first||"start"
+			//		|	"before"
+			//		|	"after"
+			//		|	"replace" (replaces nodes in this NodeList with new content)
+			//		|	"only" (removes other children of the nodes so new content is the only child)
+			//		or an offset in the childNodes property
+			// example:
+			//		appends content to the end if the position is omitted
+			//	|	dojo.query("h3 > p").addContent("hey there!");
+			// example:
+			//		add something to the front of each element that has a
+			//		"thinger" property:
+			//	|	dojo.query("[thinger]").addContent("...", "first");
+			// example:
+			//		adds a header before each element of the list
+			//	|	dojo.query(".note").addContent("<h4>NOTE:</h4>", "before");
+			// example:
+			//		add a clone of a DOM node to the end of every element in
+			//		the list, removing it from its existing parent.
+			//	|	dojo.query(".note").addContent(dojo.byId("foo"));
+			// example:
+			//		Append nodes from a templatized string.
+			//		dojo.require("dojo.string");
+			//		dojo.query(".note").addContent({
+			//			template: '<b>${id}: </b><span>${name}</span>',
+			//			id: "user332",
+			//			name: "Mr. Anderson"
+			//		});
+			// example:
+			//		Append nodes from a templatized string that also has widgets parsed.
+			//		dojo.require("dojo.string");
+			//		dojo.require("dojo.parser");
+			//		var notes = dojo.query(".note").addContent({
+			//			template: '<button dojoType="dijit.form.Button">${text}</button>',
+			//			parse: true,
+			//			text: "Send"
+			//		});
+			content = this._normalize(content, this[0]);
+			for(var i = 0, node; (node = this[i]); i++){
+				this._place(content, node, position, i > 0);
+			}
+			return this; //dojo.NodeList
+		}
+	});
+
+	/*===== return dojo.NodeList; =====*/
+	return NodeList;
+});