dojo-rails 0.9.8 → 0.9.9

data/vendor/assets/javascripts/dojo/text.js

@@ -0,0 +1,99 @@
+/*
+	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/text",["./_base/kernel","require","./has","./_base/xhr"],function(_1,_2,_3,_4){
+var _5;
+if(1){
+_5=function(_6,_7,_8){
+_4("GET",{url:_6,sync:!!_7,load:_8});
+};
+}else{
+if(_2.getText){
+_5=_2.getText;
+}else{
+console.error("dojo/text plugin failed to load because loader does not support getText");
+}
+}
+var _9={},_a=function(_b){
+if(_b){
+_b=_b.replace(/^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im,"");
+var _c=_b.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
+if(_c){
+_b=_c[1];
+}
+}else{
+_b="";
+}
+return _b;
+},_d={},_e={},_f={dynamic:true,normalize:function(id,_10){
+var _11=id.split("!"),url=_11[0];
+return (/^\./.test(url)?_10(url):url)+(_11[1]?"!"+_11[1]:"");
+},load:function(id,_12,_13){
+var _14=id.split("!"),_15=_14.length>1,_16=_14[0],url=_12.toUrl(_14[0]),_17=_d,_18=function(_19){
+_13(_15?_a(_19):_19);
+};
+if(_16 in _9){
+_17=_9[_16];
+}else{
+if(url in _12.cache){
+_17=_12.cache[url];
+}else{
+if(url in _9){
+_17=_9[url];
+}
+}
+}
+if(_17===_d){
+if(_e[url]){
+_e[url].push(_18);
+}else{
+var _1a=_e[url]=[_18];
+_5(url,!_12.async,function(_1b){
+_9[_16]=_9[url]=_1b;
+for(var i=0;i<_1a.length;){
+_1a[i++](_1b);
+}
+delete _e[url];
+});
+}
+}else{
+_18(_17);
+}
+}};
+_1.cache=function(_1c,url,_1d){
+var key;
+if(typeof _1c=="string"){
+if(/\//.test(_1c)){
+key=_1c;
+_1d=url;
+}else{
+key=_2.toUrl(_1c.replace(/\./g,"/")+(url?("/"+url):""));
+}
+}else{
+key=_1c+"";
+_1d=url;
+}
+var val=(_1d!=undefined&&typeof _1d!="string")?_1d.value:_1d,_1e=_1d&&_1d.sanitize;
+if(typeof val=="string"){
+_9[key]=val;
+return _1e?_a(val):val;
+}else{
+if(val===null){
+delete _9[key];
+return null;
+}else{
+if(!(key in _9)){
+_5(key,true,function(_1f){
+_9[key]=_1f;
+});
+}
+return _1e?_a(_9[key]):_9[key];
+}
+}
+};
+return _f;
+});

data/vendor/assets/javascripts/dojo/text.js.uncompressed.js

@@ -0,0 +1,212 @@
+define("dojo/text", ["./_base/kernel", "require", "./has", "./_base/xhr"], function(dojo, require, has, xhr){
+	// module:
+	//		dojo/text
+	// summary:
+	//		This module implements the !dojo/text plugin and the dojo.cache API.
+	// description:
+	//		We choose to include our own plugin to leverage functionality already contained in dojo
+	//		and thereby reduce the size of the plugin compared to various foreign loader implementations.
+	//		Also, this allows foreign AMD loaders to be used without their plugins.
+	//
+	//		CAUTION: this module is designed to optionally function synchronously to support the dojo v1.x synchronous
+	//		loader. This feature is outside the scope of the CommonJS plugins specification.
+
+	var getText;
+	if(1){
+		getText= function(url, sync, load){
+			xhr("GET", {url:url, sync:!!sync, load:load});
+		};
+	}else{
+		// TODOC: only works for dojo AMD loader
+		if(require.getText){
+			getText= require.getText;
+		}else{
+			console.error("dojo/text plugin failed to load because loader does not support getText");
+		}
+	}
+
+	var
+		theCache= {},
+
+		strip= function(text){
+			//Strips <?xml ...?> declarations so that external SVG and XML
+			//documents can be added to a document without worry. Also, if the string
+			//is an HTML document, only the part inside the body tag is returned.
+			if(text){
+				text= text.replace(/^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im, "");
+				var matches= text.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
+				if(matches){
+					text= matches[1];
+				}
+			}else{
+				text = "";
+			}
+			return text;
+		},
+
+		notFound = {},
+
+		pending = {},
+
+		result= {
+			dynamic:
+				// the dojo/text caches it's own resources because of dojo.cache
+				true,
+
+			normalize:function(id, toAbsMid){
+				// id is something like (path may be relative):
+				//
+				//	 "path/to/text.html"
+				//	 "path/to/text.html!strip"
+				var parts= id.split("!"),
+					url= parts[0];
+				return (/^\./.test(url) ? toAbsMid(url) : url) + (parts[1] ? "!" + parts[1] : "");
+			},
+
+			load:function(id, require, load){
+				// id is something like (path is always absolute):
+				//
+				//	 "path/to/text.html"
+				//	 "path/to/text.html!strip"
+				var
+					parts= id.split("!"),
+					stripFlag= parts.length>1,
+					absMid= parts[0],
+					url = require.toUrl(parts[0]),
+					text = notFound,
+					finish = function(text){
+						load(stripFlag ? strip(text) : text);
+					};
+				if(absMid in theCache){
+					text = theCache[absMid];
+				}else if(url in require.cache){
+					text = require.cache[url];
+				}else if(url in theCache){
+					text = theCache[url];
+				}
+				if(text===notFound){
+					if(pending[url]){
+						pending[url].push(finish);
+					}else{
+						var pendingList = pending[url] = [finish];
+						getText(url, !require.async, function(text){
+							theCache[absMid]= theCache[url]= text;
+							for(var i = 0; i<pendingList.length;){
+								pendingList[i++](text);
+							}
+							delete pending[url];
+						});
+					}
+				}else{
+					finish(text);
+				}
+			}
+		};
+
+	dojo.cache= function(/*String||Object*/module, /*String*/url, /*String||Object?*/value){
+		//	 * (string string [value]) => (module, url, value)
+		//	 * (object [value])        => (module, value), url defaults to ""
+		//
+		//	 * if module is an object, then it must be convertable to a string
+		//	 * (module, url) module + (url ? ("/" + url) : "") must be a legal argument to require.toUrl
+		//	 * value may be a string or an object; if an object then may have the properties "value" and/or "sanitize"
+		var key;
+		if(typeof module=="string"){
+			if(/\//.test(module)){
+				// module is a version 1.7+ resolved path
+				key = module;
+				value = url;
+			}else{
+				// module is a version 1.6- argument to dojo.moduleUrl
+				key = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : ""));
+			}
+		}else{
+			key = module + "";
+			value = url;
+		}
+		var
+			val = (value != undefined && typeof value != "string") ? value.value : value,
+			sanitize = value && value.sanitize;
+
+		if(typeof val == "string"){
+			//We have a string, set cache value
+			theCache[key] = val;
+			return sanitize ? strip(val) : val;
+		}else if(val === null){
+			//Remove cached value
+			delete theCache[key];
+			return null;
+		}else{
+			//Allow cache values to be empty strings. If key property does
+			//not exist, fetch it.
+			if(!(key in theCache)){
+				getText(key, true, function(text){
+					theCache[key]= text;
+				});
+			}
+			return sanitize ? strip(theCache[key]) : theCache[key];
+		}
+	};
+
+	return result;
+
+/*=====
+dojo.cache = function(module, url, value){
+	// summary:
+	//		A getter and setter for storing the string content associated with the
+	//		module and url arguments.
+	// description:
+	//		If module is a string that contains slashes, then it is interpretted as a fully
+	//		resolved path (typically a result returned by require.toUrl), and url should not be
+	//		provided. This is the preferred signature. If module is a string that does not
+	//		contain slashes, then url must also be provided and module and url are used to
+	//		call `dojo.moduleUrl()` to generate a module URL. This signature is deprecated.
+	//		If value is specified, the cache value for the moduleUrl will be set to
+	//		that value. Otherwise, dojo.cache will fetch the moduleUrl and store it
+	//		in its internal cache and return that cached value for the URL. To clear
+	//		a cache value pass null for value. Since XMLHttpRequest (XHR) is used to fetch the
+	//		the URL contents, only modules on the same domain of the page can use this capability.
+	//		The build system can inline the cache values though, to allow for xdomain hosting.
+	// module: String||Object
+	//		If a String with slashes, a fully resolved path; if a String without slashes, the
+	//		module name to use for the base part of the URL, similar to module argument
+	//		to `dojo.moduleUrl`. If an Object, something that has a .toString() method that
+	//		generates a valid path for the cache item. For example, a dojo._Url object.
+	// url: String
+	//		The rest of the path to append to the path derived from the module argument. If
+	//		module is an object, then this second argument should be the "value" argument instead.
+	// value: String||Object?
+	//		If a String, the value to use in the cache for the module/url combination.
+	//		If an Object, it can have two properties: value and sanitize. The value property
+	//		should be the value to use in the cache, and sanitize can be set to true or false,
+	//		to indicate if XML declarations should be removed from the value and if the HTML
+	//		inside a body tag in the value should be extracted as the real value. The value argument
+	//		or the value property on the value argument are usually only used by the build system
+	//		as it inlines cache content.
+	//	example:
+	//		To ask dojo.cache to fetch content and store it in the cache (the dojo["cache"] style
+	//		of call is used to avoid an issue with the build system erroneously trying to intern
+	//		this example. To get the build system to intern your dojo.cache calls, use the
+	//		"dojo.cache" style of call):
+	//		| //If template.html contains "<h1>Hello</h1>" that will be
+	//		| //the value for the text variable.
+	//		| var text = dojo["cache"]("my.module", "template.html");
+	//	example:
+	//		To ask dojo.cache to fetch content and store it in the cache, and sanitize the input
+	//		 (the dojo["cache"] style of call is used to avoid an issue with the build system
+	//		erroneously trying to intern this example. To get the build system to intern your
+	//		dojo.cache calls, use the "dojo.cache" style of call):
+	//		| //If template.html contains "<html><body><h1>Hello</h1></body></html>", the
+	//		| //text variable will contain just "<h1>Hello</h1>".
+	//		| var text = dojo["cache"]("my.module", "template.html", {sanitize: true});
+	//	example:
+	//		Same example as previous, but demostrates how an object can be passed in as
+	//		the first argument, then the value argument can then be the second argument.
+	//		| //If template.html contains "<html><body><h1>Hello</h1></body></html>", the
+	//		| //text variable will contain just "<h1>Hello</h1>".
+	//		| var text = dojo["cache"](new dojo._Url("my/module/template.html"), {sanitize: true});
+	return val; //String
+};
+=====*/
+});
+

data/vendor/assets/javascripts/dojo/topic.js

@@ -0,0 +1,15 @@
+/*
+	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/topic",["./Evented"],function(_1){
+var _2=new _1;
+return {publish:function(_3,_4){
+return _2.emit.apply(_2,arguments);
+},subscribe:function(_5,_6){
+return _2.on.apply(_2,arguments);
+}};
+});

data/vendor/assets/javascripts/dojo/topic.js.uncompressed.js

@@ -0,0 +1,33 @@
+define("dojo/topic", ["./Evented"], function(Evented){
+	// summary:
+	//		The export of this module is a pubsub hub
+	//		You can also use listen function itself as a pub/sub hub:
+	//		| 	topic.subscribe("some/topic", function(event){
+	//		|	... do something with event
+	//		|	});
+	//		|	topic.publish("some/topic", {name:"some event", ...});
+
+	var hub = new Evented;
+	return {
+		publish: function(topic, event){
+			// summary:
+			//		Publishes a message to a topic on the pub/sub hub. All arguments after
+			// 		the first will be passed to the subscribers, so any number of arguments
+			// 		can be provided (not just event).
+			// topic: String
+			//		The name of the topic to publish to
+			// event: Object
+			//		An event to distribute to the topic listeners
+			return hub.emit.apply(hub, arguments);
+		},
+		subscribe: function(topic, listener){
+			// summary:
+			//		Subcribes to a topic on the pub/sub hub
+			// topic: String
+			//		The topic to subscribe to
+			//	listener: Function
+			//		A function to call when a message is published to the given topic
+			return hub.on.apply(hub, arguments);
+		}
+	}
+});

data/vendor/assets/javascripts/dojo/touch.js

@@ -0,0 +1,17 @@
+/*
+	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/touch",["./_base/kernel","./on","./has","./mouse"],function(_1,on,_2,_3){
+function _4(_5){
+return function(_6,_7){
+return on(_6,_5,_7);
+};
+};
+var _8=_2("touch");
+_1.touch={press:_4(_8?"touchstart":"mousedown"),move:_4(_8?"touchmove":"mousemove"),release:_4(_8?"touchend":"mouseup"),cancel:_8?_4("touchcancel"):_3.leave};
+return _1.touch;
+});

data/vendor/assets/javascripts/dojo/touch.js.uncompressed.js

@@ -0,0 +1,89 @@
+define("dojo/touch", ["./_base/kernel", "./on", "./has", "./mouse"], function(dojo, on, has, mouse){
+// module:
+//		dojo/touch
+
+/*=====
+	dojo.touch = {
+		// summary:
+		//		This module provides unified touch event handlers by exporting
+		//		press, move, release and cancel which can also run well on desktop.
+		//		Based on http://dvcs.w3.org/hg/webevents/raw-file/tip/touchevents.html
+		//
+		// example:
+		//		1. Used with dojo.connect()
+		//		|	dojo.connect(node, dojo.touch.press, function(e){});
+		//		|	dojo.connect(node, dojo.touch.move, function(e){});
+		//		|	dojo.connect(node, dojo.touch.release, function(e){});
+		//		|	dojo.connect(node, dojo.touch.cancel, function(e){});
+		//
+		//		2. Used with dojo.on
+		//		|	define(["dojo/on", "dojo/touch"], function(on, touch){
+		//		|		on(node, touch.press, function(e){});
+		//		|		on(node, touch.move, function(e){});
+		//		|		on(node, touch.release, function(e){});
+		//		|		on(node, touch.cancel, function(e){});
+		//
+		//		3. Used with dojo.touch.* directly
+		//		|	dojo.touch.press(node, function(e){});
+		//		|	dojo.touch.move(node, function(e){});
+		//		|	dojo.touch.release(node, function(e){});
+		//		|	dojo.touch.cancel(node, function(e){});
+		
+		press: function(node, listener){
+			// summary:
+			//		Register a listener to 'touchstart'|'mousedown' for the given node
+			// node: Dom
+			//		Target node to listen to
+			// listener: Function
+			//		Callback function
+			// returns:
+			//		A handle which will be used to remove the listener by handle.remove()
+		},
+		move: function(node, listener){
+			// summary:
+			//		Register a listener to 'touchmove'|'mousemove' for the given node
+			// node: Dom
+			//		Target node to listen to
+			// listener: Function
+			//		Callback function
+			// returns:
+			//		A handle which will be used to remove the listener by handle.remove()
+		},
+		release: function(node, listener){
+			// summary:
+			//		Register a listener to 'touchend'|'mouseup' for the given node
+			// node: Dom
+			//		Target node to listen to
+			// listener: Function
+			//		Callback function
+			// returns:
+			//		A handle which will be used to remove the listener by handle.remove()
+		},
+		cancel: function(node, listener){
+			// summary:
+			//		Register a listener to 'touchcancel'|'mouseleave' for the given node
+			// node: Dom
+			//		Target node to listen to
+			// listener: Function
+			//		Callback function
+			// returns:
+			//		A handle which will be used to remove the listener by handle.remove()
+		}
+	};
+=====*/
+
+	function _handle(/*String - press | move | release | cancel*/type){
+		return function(node, listener){//called by on(), see dojo.on
+			return on(node, type, listener);
+		};
+	}
+	var touch = has("touch");
+	//device neutral events - dojo.touch.press|move|release|cancel
+	dojo.touch = {
+		press: _handle(touch ? "touchstart": "mousedown"),
+		move: _handle(touch ? "touchmove": "mousemove"),
+		release: _handle(touch ? "touchend": "mouseup"),
+		cancel: touch ? _handle("touchcancel") : mouse.leave
+	};
+	return dojo.touch;
+});