dojo-rails 0.9.8 → 0.9.9

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

@@ -0,0 +1,141 @@
+/*
+	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/dom-construct",["exports","./_base/kernel","./_base/sniff","./_base/window","./dom","./dom-attr","./on"],function(_1,_2,_3,_4,_5,_6,on){
+var _7={option:["select"],tbody:["table"],thead:["table"],tfoot:["table"],tr:["table","tbody"],td:["table","tbody","tr"],th:["table","thead","tr"],legend:["fieldset"],caption:["table"],colgroup:["table"],col:["table","colgroup"],li:["ul"]},_8=/<\s*([\w\:]+)/,_9={},_a=0,_b="__"+_2._scopeName+"ToDomId";
+for(var _c in _7){
+if(_7.hasOwnProperty(_c)){
+var tw=_7[_c];
+tw.pre=_c=="option"?"<select multiple=\"multiple\">":"<"+tw.join("><")+">";
+tw.post="</"+tw.reverse().join("></")+">";
+}
+}
+function _d(_e,_f){
+var _10=_f.parentNode;
+if(_10){
+_10.insertBefore(_e,_f);
+}
+};
+function _11(_12,ref){
+var _13=ref.parentNode;
+if(_13){
+if(_13.lastChild==ref){
+_13.appendChild(_12);
+}else{
+_13.insertBefore(_12,ref.nextSibling);
+}
+}
+};
+var _14=null,_15;
+on(window,"unload",function(){
+_14=null;
+});
+_1.toDom=function toDom(_16,doc){
+doc=doc||_4.doc;
+var _17=doc[_b];
+if(!_17){
+doc[_b]=_17=++_a+"";
+_9[_17]=doc.createElement("div");
+}
+_16+="";
+var _18=_16.match(_8),tag=_18?_18[1].toLowerCase():"",_19=_9[_17],_1a,i,fc,df;
+if(_18&&_7[tag]){
+_1a=_7[tag];
+_19.innerHTML=_1a.pre+_16+_1a.post;
+for(i=_1a.length;i;--i){
+_19=_19.firstChild;
+}
+}else{
+_19.innerHTML=_16;
+}
+if(_19.childNodes.length==1){
+return _19.removeChild(_19.firstChild);
+}
+df=doc.createDocumentFragment();
+while(fc=_19.firstChild){
+df.appendChild(fc);
+}
+return df;
+};
+_1.place=function place(_1b,_1c,_1d){
+_1c=_5.byId(_1c);
+if(typeof _1b=="string"){
+_1b=/^\s*</.test(_1b)?_1.toDom(_1b,_1c.ownerDocument):_5.byId(_1b);
+}
+if(typeof _1d=="number"){
+var cn=_1c.childNodes;
+if(!cn.length||cn.length<=_1d){
+_1c.appendChild(_1b);
+}else{
+_d(_1b,cn[_1d<0?0:_1d]);
+}
+}else{
+switch(_1d){
+case "before":
+_d(_1b,_1c);
+break;
+case "after":
+_11(_1b,_1c);
+break;
+case "replace":
+_1c.parentNode.replaceChild(_1b,_1c);
+break;
+case "only":
+_1.empty(_1c);
+_1c.appendChild(_1b);
+break;
+case "first":
+if(_1c.firstChild){
+_d(_1b,_1c.firstChild);
+break;
+}
+default:
+_1c.appendChild(_1b);
+}
+}
+return _1b;
+};
+_1.create=function create(tag,_1e,_1f,pos){
+var doc=_4.doc;
+if(_1f){
+_1f=_5.byId(_1f);
+doc=_1f.ownerDocument;
+}
+if(typeof tag=="string"){
+tag=doc.createElement(tag);
+}
+if(_1e){
+_6.set(tag,_1e);
+}
+if(_1f){
+_1.place(tag,_1f,pos);
+}
+return tag;
+};
+_1.empty=_3("ie")?function(_20){
+_20=_5.byId(_20);
+for(var c;c=_20.lastChild;){
+_1.destroy(c);
+}
+}:function(_21){
+_5.byId(_21).innerHTML="";
+};
+_1.destroy=function destroy(_22){
+_22=_5.byId(_22);
+try{
+var doc=_22.ownerDocument;
+if(!_14||_15!=doc){
+_14=doc.createElement("div");
+_15=doc;
+}
+_14.appendChild(_22.parentNode?_22.parentNode.removeChild(_22):_22);
+_14.innerHTML="";
+}
+catch(e){
+}
+};
+});

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

@@ -0,0 +1,376 @@
+define("dojo/dom-construct", ["exports", "./_base/kernel", "./_base/sniff", "./_base/window", "./dom", "./dom-attr", "./on"],
+		function(exports, dojo, has, win, dom, attr, on){
+	// module:
+	//		dojo/dom-construct
+	// summary:
+	//		This module defines the core dojo DOM construction API.
+
+	/*=====
+	dojo.toDom = function(frag, doc){
+		// summary:
+		//		instantiates an HTML fragment returning the corresponding DOM.
+		// frag: String
+		//		the HTML fragment
+		// doc: DocumentNode?
+		//		optional document to use when creating DOM nodes, defaults to
+		//		dojo.doc if not specified.
+		// returns: DocumentFragment
+		//
+		// example:
+		//		Create a table row:
+		//	|	var tr = dojo.toDom("<tr><td>First!</td></tr>");
+	};
+	=====*/
+
+	/*=====
+	dojo._toDom = function(frag, doc){
+		// summary:
+		//		Existing alias for `dojo.toDom`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.place = function(node, refNode, position){
+		// summary:
+		//		Attempt to insert node into the DOM, choosing from various positioning options.
+		//		Returns the first argument resolved to a DOM node.
+		//
+		// node: DOMNode|String
+		//		id or node reference, or HTML fragment starting with "<" to place relative to refNode
+		//
+		// refNode: DOMNode|String
+		//		id or node reference to use as basis for placement
+		//
+		// position: String|Number?
+		//		string noting the position of node relative to refNode or a
+		//		number indicating the location in the childNodes collection of refNode.
+		//		Accepted string values are:
+		//	|	* before
+		//	|	* after
+		//	|	* replace
+		//	|	* only
+		//	|	* first
+		//	|	* last
+		//		"first" and "last" indicate positions as children of refNode, "replace" replaces refNode,
+		//		"only" replaces all children.  position defaults to "last" if not specified
+		//
+		// returns: DOMNode
+		//		Returned values is the first argument resolved to a DOM node.
+		//
+		//		.place() is also a method of `dojo.NodeList`, allowing `dojo.query` node lookups.
+		//
+		// example:
+		//		Place a node by string id as the last child of another node by string id:
+		//	|	dojo.place("someNode", "anotherNode");
+		//
+		// example:
+		//		Place a node by string id before another node by string id
+		//	|	dojo.place("someNode", "anotherNode", "before");
+		//
+		// example:
+		//		Create a Node, and place it in the body element (last child):
+		//	|	dojo.place("<div></div>", dojo.body());
+		//
+		// example:
+		//		Put a new LI as the first child of a list by id:
+		//	|	dojo.place("<li></li>", "someUl", "first");
+	};
+	=====*/
+
+	/*=====
+	dojo.create = function(tag, attrs, refNode, pos){
+		// summary:
+		//		Create an element, allowing for optional attribute decoration
+		//		and placement.
+		//
+		// description:
+		//		A DOM Element creation function. A shorthand method for creating a node or
+		//		a fragment, and allowing for a convenient optional attribute setting step,
+		//		as well as an optional DOM placement reference.
+		//|
+		//		Attributes are set by passing the optional object through `dojo.setAttr`.
+		//		See `dojo.setAttr` for noted caveats and nuances, and API if applicable.
+		//|
+		//		Placement is done via `dojo.place`, assuming the new node to be the action
+		//		node, passing along the optional reference node and position.
+		//
+		// tag: DOMNode|String
+		//		A string of the element to create (eg: "div", "a", "p", "li", "script", "br"),
+		//		or an existing DOM node to process.
+		//
+		// attrs: Object
+		//		An object-hash of attributes to set on the newly created node.
+		//		Can be null, if you don't want to set any attributes/styles.
+		//		See: `dojo.setAttr` for a description of available attributes.
+		//
+		// refNode: DOMNode?|String?
+		//		Optional reference node. Used by `dojo.place` to place the newly created
+		//		node somewhere in the dom relative to refNode. Can be a DomNode reference
+		//		or String ID of a node.
+		//
+		// pos: String?
+		//		Optional positional reference. Defaults to "last" by way of `dojo.place`,
+		//		though can be set to "first","after","before","last", "replace" or "only"
+		//		to further control the placement of the new node relative to the refNode.
+		//		'refNode' is required if a 'pos' is specified.
+		//
+		// returns: DOMNode
+		//
+		// example:
+		//		Create a DIV:
+		//	|	var n = dojo.create("div");
+		//
+		// example:
+		//		Create a DIV with content:
+		//	|	var n = dojo.create("div", { innerHTML:"<p>hi</p>" });
+		//
+		// example:
+		//		Place a new DIV in the BODY, with no attributes set
+		//	|	var n = dojo.create("div", null, dojo.body());
+		//
+		// example:
+		//		Create an UL, and populate it with LI's. Place the list as the first-child of a
+		//		node with id="someId":
+		//	|	var ul = dojo.create("ul", null, "someId", "first");
+		//	|	var items = ["one", "two", "three", "four"];
+		//	|	dojo.forEach(items, function(data){
+		//	|		dojo.create("li", { innerHTML: data }, ul);
+		//	|	});
+		//
+		// example:
+		//		Create an anchor, with an href. Place in BODY:
+		//	|	dojo.create("a", { href:"foo.html", title:"Goto FOO!" }, dojo.body());
+		//
+		// example:
+		//		Create a `dojo.NodeList()` from a new element (for syntatic sugar):
+		//	|	dojo.query(dojo.create('div'))
+		//	|		.addClass("newDiv")
+		//	|		.onclick(function(e){ console.log('clicked', e.target) })
+		//	|		.place("#someNode"); // redundant, but cleaner.
+	};
+	=====*/
+
+	/*=====
+	dojo.empty = function(node){
+			// summary:
+			//		safely removes all children of the node.
+			// node: DOMNode|String
+			//		a reference to a DOM node or an id.
+			// example:
+			//		Destroy node's children byId:
+			//	|	dojo.empty("someId");
+			//
+			// example:
+			//		Destroy all nodes' children in a list by reference:
+			//	|	dojo.query(".someNode").forEach(dojo.empty);
+	}
+	=====*/
+
+	/*=====
+	dojo.destroy = function(node){
+		// summary:
+		//		Removes a node from its parent, clobbering it and all of its
+		//		children.
+		//
+		// description:
+		//		Removes a node from its parent, clobbering it and all of its
+		//		children. Function only works with DomNodes, and returns nothing.
+		//
+		// node: DOMNode|String
+		//		A String ID or DomNode reference of the element to be destroyed
+		//
+		// example:
+		//		Destroy a node byId:
+		//	|	dojo.destroy("someId");
+		//
+		// example:
+		//		Destroy all nodes in a list by reference:
+		//	|	dojo.query(".someNode").forEach(dojo.destroy);
+	};
+	=====*/
+
+	/*=====
+	dojo._destroyElement = function(node){
+		// summary:
+		//		Existing alias for `dojo.destroy`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	// support stuff for dojo.toDom
+	var tagWrap = {
+			option: ["select"],
+			tbody: ["table"],
+			thead: ["table"],
+			tfoot: ["table"],
+			tr: ["table", "tbody"],
+			td: ["table", "tbody", "tr"],
+			th: ["table", "thead", "tr"],
+			legend: ["fieldset"],
+			caption: ["table"],
+			colgroup: ["table"],
+			col: ["table", "colgroup"],
+			li: ["ul"]
+		},
+		reTag = /<\s*([\w\:]+)/,
+		masterNode = {}, masterNum = 0,
+		masterName = "__" + dojo._scopeName + "ToDomId";
+
+	// generate start/end tag strings to use
+	// for the injection for each special tag wrap case.
+	for(var param in tagWrap){
+		if(tagWrap.hasOwnProperty(param)){
+			var tw = tagWrap[param];
+			tw.pre = param == "option" ? '<select multiple="multiple">' : "<" + tw.join("><") + ">";
+			tw.post = "</" + tw.reverse().join("></") + ">";
+			// the last line is destructive: it reverses the array,
+			// but we don't care at this point
+		}
+	}
+
+	function _insertBefore(/*DomNode*/node, /*DomNode*/ref){
+		var parent = ref.parentNode;
+		if(parent){
+			parent.insertBefore(node, ref);
+		}
+	}
+
+	function _insertAfter(/*DomNode*/node, /*DomNode*/ref){
+		// summary:
+		//		Try to insert node after ref
+		var parent = ref.parentNode;
+		if(parent){
+			if(parent.lastChild == ref){
+				parent.appendChild(node);
+			}else{
+				parent.insertBefore(node, ref.nextSibling);
+			}
+		}
+	}
+
+	var _destroyContainer = null,
+		_destroyDoc;
+		on(window, "unload", function(){
+		_destroyContainer = null; //prevent IE leak
+	});
+	
+	exports.toDom = function toDom(frag, doc){
+		doc = doc || win.doc;
+		var masterId = doc[masterName];
+		if(!masterId){
+			doc[masterName] = masterId = ++masterNum + "";
+			masterNode[masterId] = doc.createElement("div");
+		}
+
+		// make sure the frag is a string.
+		frag += "";
+
+		// find the starting tag, and get node wrapper
+		var match = frag.match(reTag),
+			tag = match ? match[1].toLowerCase() : "",
+			master = masterNode[masterId],
+			wrap, i, fc, df;
+		if(match && tagWrap[tag]){
+			wrap = tagWrap[tag];
+			master.innerHTML = wrap.pre + frag + wrap.post;
+			for(i = wrap.length; i; --i){
+				master = master.firstChild;
+			}
+		}else{
+			master.innerHTML = frag;
+		}
+
+		// one node shortcut => return the node itself
+		if(master.childNodes.length == 1){
+			return master.removeChild(master.firstChild); // DOMNode
+		}
+
+		// return multiple nodes as a document fragment
+		df = doc.createDocumentFragment();
+		while(fc = master.firstChild){ // intentional assignment
+			df.appendChild(fc);
+		}
+		return df; // DOMNode
+	};
+
+	exports.place = function place(/*DOMNode|String*/node, /*DOMNode|String*/refNode, /*String|Number?*/position){
+		refNode = dom.byId(refNode);
+		if(typeof node == "string"){ // inline'd type check
+			node = /^\s*</.test(node) ? exports.toDom(node, refNode.ownerDocument) : dom.byId(node);
+		}
+		if(typeof position == "number"){ // inline'd type check
+			var cn = refNode.childNodes;
+			if(!cn.length || cn.length <= position){
+				refNode.appendChild(node);
+			}else{
+				_insertBefore(node, cn[position < 0 ? 0 : position]);
+			}
+		}else{
+			switch(position){
+				case "before":
+					_insertBefore(node, refNode);
+					break;
+				case "after":
+					_insertAfter(node, refNode);
+					break;
+				case "replace":
+					refNode.parentNode.replaceChild(node, refNode);
+					break;
+				case "only":
+					exports.empty(refNode);
+					refNode.appendChild(node);
+					break;
+				case "first":
+					if(refNode.firstChild){
+						_insertBefore(node, refNode.firstChild);
+						break;
+					}
+					// else fallthrough...
+				default: // aka: last
+					refNode.appendChild(node);
+			}
+		}
+		return node; // DomNode
+	};
+
+	exports.create = function create(/*DOMNode|String*/tag, /*Object*/attrs, /*DOMNode?|String?*/refNode, /*String?*/pos){
+		var doc = win.doc;
+		if(refNode){
+			refNode = dom.byId(refNode);
+			doc = refNode.ownerDocument;
+		}
+		if(typeof tag == "string"){ // inline'd type check
+			tag = doc.createElement(tag);
+		}
+		if(attrs){ attr.set(tag, attrs); }
+		if(refNode){ exports.place(tag, refNode, pos); }
+		return tag; // DomNode
+	};
+
+	exports.empty =
+				has("ie") ? function(node){
+			node = dom.byId(node);
+			for(var c; c = node.lastChild;){ // intentional assignment
+				exports.destroy(c);
+			}
+		} :
+				function(node){
+			dom.byId(node).innerHTML = "";
+		};
+
+	exports.destroy = function destroy(/*DOMNode|String*/node){
+		node = dom.byId(node);
+		try{
+			var doc = node.ownerDocument;
+			// cannot use _destroyContainer.ownerDocument since this can throw an exception on IE
+			if(!_destroyContainer || _destroyDoc != doc){
+				_destroyContainer = doc.createElement("div");
+				_destroyDoc = doc;
+			}
+			_destroyContainer.appendChild(node.parentNode ? node.parentNode.removeChild(node) : node);
+			// NOTE: see http://trac.dojotoolkit.org/ticket/2931. This may be a bug and not a feature
+			_destroyContainer.innerHTML = "";
+		}catch(e){
+			/* squelch */
+		}
+	};
+});