dojo-rails 0.9.8 → 0.9.9

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

@@ -0,0 +1,26 @@
+/*
+	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/json",["./kernel","../json"],function(_1,_2){
+_1.fromJson=function(js){
+return eval("("+js+")");
+};
+_1._escapeString=_2.stringify;
+_1.toJsonIndentStr="\t";
+_1.toJson=function(it,_3){
+return _2.stringify(it,function(_4,_5){
+if(_5){
+var tf=_5.__json__||_5.json;
+if(typeof tf=="function"){
+return tf.call(_5);
+}
+}
+return _5;
+},_3&&_1.toJsonIndentStr);
+};
+return _1;
+});

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

@@ -0,0 +1,85 @@
+define("dojo/_base/json", ["./kernel", "../json"], function(dojo, json){
+  // module:
+  //    dojo/_base/json
+  // summary:
+  //    This module defines the dojo JSON API.
+
+dojo.fromJson = function(/*String*/ js){
+	// summary:
+	//		Parses a JavaScript expression and returns a JavaScript value.
+	// description:
+	//		Throws for invalid JavaScript expressions. It does not use a strict JSON parser. It
+	//		always delegates to eval(). The content passed to this method must therefore come
+	//		from a trusted source.
+	//		It is recommend that you use dojo/json's parse function for an
+	//		implementation uses the (faster) native JSON parse when available.
+	// js:
+	//		a string literal of a JavaScript expression, for instance:
+	//			`'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`
+
+	return eval("(" + js + ")"); // Object
+};
+
+/*=====
+dojo._escapeString = function(){
+	// summary:
+	//		Adds escape sequences for non-visual characters, double quote and
+	//		backslash and surrounds with double quotes to form a valid string
+	//		literal.
+};
+=====*/
+dojo._escapeString = json.stringify; // just delegate to json.stringify
+
+dojo.toJsonIndentStr = "\t";
+dojo.toJson = function(/*Object*/ it, /*Boolean?*/ prettyPrint){
+	// summary:
+	//		Returns a [JSON](http://json.org) serialization of an object.
+	// description:
+	//		Returns a [JSON](http://json.org) serialization of an object.
+	//		Note that this doesn't check for infinite recursion, so don't do that!
+	//		It is recommend that you use dojo/json's stringify function for an lighter
+	//		and faster implementation that matches the native JSON API and uses the
+	//		native JSON serializer when available.
+	// it:
+	//		an object to be serialized. Objects may define their own
+	//		serialization via a special "__json__" or "json" function
+	//		property. If a specialized serializer has been defined, it will
+	//		be used as a fallback.
+	//		Note that in 1.6, toJson would serialize undefined, but this no longer supported
+	//		since it is not supported by native JSON serializer.
+	// prettyPrint:
+	//		if true, we indent objects and arrays to make the output prettier.
+	//		The variable `dojo.toJsonIndentStr` is used as the indent string --
+	//		to use something other than the default (tab), change that variable
+	//		before calling dojo.toJson().
+	//		Note that if native JSON support is available, it will be used for serialization,
+	//		and native implementations vary on the exact spacing used in pretty printing.
+	// returns:
+	// 		A JSON string serialization of the passed-in object.
+	// example:
+	//		simple serialization of a trivial object
+	//		|	var jsonStr = dojo.toJson({ howdy: "stranger!", isStrange: true });
+	//		|	doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr);
+	// example:
+	//		a custom serializer for an objects of a particular class:
+	//		|	dojo.declare("Furby", null, {
+	//		|		furbies: "are strange",
+	//		|		furbyCount: 10,
+	//		|		__json__: function(){
+	//		|		},
+	//		|	});
+
+	// use dojo/json
+	return json.stringify(it, function(key, value){
+		if(value){
+			var tf = value.__json__||value.json;
+			if(typeof tf == "function"){
+				return tf.call(value);
+			}
+		}
+		return value;
+	}, prettyPrint && dojo.toJsonIndentStr);	// String
+};
+
+return dojo;
+});

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

@@ -0,0 +1,114 @@
+/*
+	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/kernel",["../has","./config","require","module"],function(_1,_2,_3,_4){
+var i,p,_5={},_6={},_7={config:_2,global:this,dijit:_5,dojox:_6};
+var _8={dojo:["dojo",_7],dijit:["dijit",_5],dojox:["dojox",_6]},_9=(_3.packs&&_3.packs[_4.id.match(/[^\/]+/)[0]].packageMap)||{},_a;
+for(p in _9){
+if(_8[p]){
+_8[p][0]=_9[p];
+}else{
+_8[p]=[_9[p],{}];
+}
+}
+for(p in _8){
+_a=_8[p];
+_a[1]._scopeName=_a[0];
+if(!_2.noGlobals){
+this[_a[0]]=_a[1];
+}
+}
+_7.scopeMap=_8;
+_7.baseUrl=_7.config.baseUrl=_3.baseUrl;
+_7.isAsync=!1||_3.async;
+_7.locale=_2.locale;
+var _b="$Rev: 28982 $".match(/\d+/);
+_7.version={major:1,minor:7,patch:3,flag:"",revision:_b?+_b[0]:NaN,toString:function(){
+var v=_7.version;
+return v.major+"."+v.minor+"."+v.patch+v.flag+" ("+v.revision+")";
+}};
+true||_1.add("extend-dojo",1);
+_7.eval=function(_c){
+};
+(Function("d","d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(_7);
+if(0){
+_7.exit=function(_d){
+quit(_d);
+};
+}else{
+_7.exit=function(){
+};
+}
+true||_1.add("dojo-guarantee-console",1);
+if(1){
+typeof console!="undefined"||(console={});
+var cn=["assert","count","debug","dir","dirxml","error","group","groupEnd","info","profile","profileEnd","time","timeEnd","trace","warn","log"];
+var tn;
+i=0;
+while((tn=cn[i++])){
+if(!console[tn]){
+(function(){
+var _e=tn+"";
+console[_e]=("log" in console)?function(){
+var a=Array.apply({},arguments);
+a.unshift(_e+":");
+console["log"](a.join(" "));
+}:function(){
+};
+console[_e]._fake=true;
+})();
+}
+}
+}
+_1.add("dojo-debug-messages",!!_2.isDebug);
+if(_1("dojo-debug-messages")){
+_7.deprecated=function(_f,_10,_11){
+var _12="DEPRECATED: "+_f;
+if(_10){
+_12+=" "+_10;
+}
+if(_11){
+_12+=" -- will be removed in version: "+_11;
+}
+console.warn(_12);
+};
+_7.experimental=function(_13,_14){
+var _15="EXPERIMENTAL: "+_13+" -- APIs subject to change without notice.";
+if(_14){
+_15+=" "+_14;
+}
+console.warn(_15);
+};
+}else{
+_7.deprecated=_7.experimental=function(){
+};
+}
+true||_1.add("dojo-modulePaths",1);
+if(1){
+if(_2.modulePaths){
+_7.deprecated("dojo.modulePaths","use paths configuration");
+var _16={};
+for(p in _2.modulePaths){
+_16[p.replace(/\./g,"/")]=_2.modulePaths[p];
+}
+_3({paths:_16});
+}
+}
+true||_1.add("dojo-moduleUrl",1);
+if(1){
+_7.moduleUrl=function(_17,url){
+_7.deprecated("dojo.moduleUrl()","use require.toUrl","2.0");
+var _18=null;
+if(_17){
+_18=_3.toUrl(_17.replace(/\./g,"/")+(url?("/"+url):"")+"/*.*").replace(/\/\*\.\*/,"")+(url?"":"/");
+}
+return _18;
+};
+}
+_7._hasResource={};
+return _7;
+});

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

@@ -0,0 +1,302 @@
+define("dojo/_base/kernel", ["../has", "./config", "require", "module"], function(has, config, require, module){
+	// module:
+	//		dojo/_base/kernel
+	// summary:
+	//		This module is the foundational module of the dojo boot sequence; it defines the dojo object.
+	var
+		// loop variables for this module
+		i, p,
+
+		// create dojo, dijit, and dojox
+		// FIXME: in 2.0 remove dijit, dojox being created by dojo
+		dijit = {},
+		dojox = {},
+		dojo = {
+			// notice dojo takes ownership of the value of the config module
+			config:config,
+			global:this,
+			dijit:dijit,
+			dojox:dojox
+		};
+
+
+	// Configure the scope map. For a 100% AMD application, the scope map is not needed other than to provide
+	// a _scopeName property for the dojo, dijit, and dojox root object so those packages can create
+	// unique names in the global space.
+	//
+	// Built, legacy modules use the scope map to allow those modules to be expressed as if dojo, dijit, and dojox,
+	// where global when in fact they are either global under different names or not global at all. In v1.6-, the
+	// config variable "scopeMap" was used to map names as used within a module to global names. This has been
+	// subsumed by the dojo packageMap configuration variable which relocates packages to different names. See
+	// http://livedocs.dojotoolkit.org/developer/design/loader#legacy-cross-domain-mode for details.
+	//
+	// The following computations contort the packageMap for this dojo instance into a scopeMap.
+	var scopeMap =
+			// a map from a name used in a legacy module to the (global variable name, object addressed by that name)
+			// always map dojo, dijit, and dojox
+			{
+				dojo:["dojo", dojo],
+				dijit:["dijit", dijit],
+				dojox:["dojox", dojox]
+			},
+
+		packageMap =
+			// the package map for this dojo instance; note, a foreign loader or no pacakgeMap results in the above default config
+			(require.packs && require.packs[module.id.match(/[^\/]+/)[0]].packageMap) || {},
+
+		item;
+
+	// process all mapped top-level names for this instance of dojo
+	for(p in packageMap){
+		if(scopeMap[p]){
+			// mapped dojo, dijit, or dojox
+			scopeMap[p][0] = packageMap[p];
+		}else{
+			// some other top-level name
+			scopeMap[p] = [packageMap[p], {}];
+		}
+	}
+
+	// publish those names to _scopeName and, optionally, the global namespace
+	for(p in scopeMap){
+		item = scopeMap[p];
+		item[1]._scopeName = item[0];
+		if(!config.noGlobals){
+			this[item[0]] = item[1];
+		}
+	}
+	dojo.scopeMap = scopeMap;
+
+	// FIXME: dojo.baseUrl and dojo.config.baseUrl should be deprecated
+	dojo.baseUrl = dojo.config.baseUrl = require.baseUrl;
+	dojo.isAsync = !1 || require.async;
+	dojo.locale = config.locale;
+
+	/*=====
+		dojo.version = function(){
+			// summary:
+			//		Version number of the Dojo Toolkit
+			// major: Integer
+			//		Major version. If total version is "1.2.0beta1", will be 1
+			// minor: Integer
+			//		Minor version. If total version is "1.2.0beta1", will be 2
+			// patch: Integer
+			//		Patch version. If total version is "1.2.0beta1", will be 0
+			// flag: String
+			//		Descriptor flag. If total version is "1.2.0beta1", will be "beta1"
+			// revision: Number
+			//		The SVN rev from which dojo was pulled
+			this.major = 0;
+			this.minor = 0;
+			this.patch = 0;
+			this.flag = "";
+			this.revision = 0;
+		}
+	=====*/
+	var rev = "$Rev: 28982 $".match(/\d+/);
+	dojo.version = {
+		major: 1, minor: 7, patch: 3, flag: "",
+		revision: rev ? +rev[0] : NaN,
+		toString: function(){
+			var v = dojo.version;
+			return v.major + "." + v.minor + "." + v.patch + v.flag + " (" + v.revision + ")";	// String
+		}
+	};
+
+
+	// If 1 is truthy, then as a dojo module is defined it should push it's definitions
+	// into the dojo object, and conversely. In 2.0, it will likely be unusual to augment another object
+	// as a result of defining a module. This has feature gives a way to force 2.0 behavior as the code
+	// is migrated. Absent specific advice otherwise, set extend-dojo to truthy.
+	true || has.add("extend-dojo", 1);
+
+
+	dojo.eval = function(scriptText){
+		//	summary:
+		//		A legacy method created for use exclusively by internal Dojo methods. Do not use this method
+		//		directly unless you understand its possibly-different implications on the platforms your are targeting.
+		//	description:
+		//		Makes an attempt to evaluate scriptText in the global scope. The function works correctly for browsers
+		//		that support indirect eval.
+		//
+		//		As usual, IE does not. On IE, the only way to implement global eval is to
+		//		use execScript. Unfortunately, execScript does not return a value and breaks some current usages of dojo.eval.
+		//		This implementation uses the technique of executing eval in the scope of a function that is a single scope
+		//		frame below the global scope; thereby coming close to the global scope. Note carefully that
+		//
+		//		dojo.eval("var pi = 3.14;");
+		//
+		//		will define global pi in non-IE environments, but define pi only in a temporary local scope for IE. If you want
+		//		to define a global variable using dojo.eval, write something like
+		//
+		//		dojo.eval("window.pi = 3.14;")
+		//	scriptText:
+		//		The text to evaluation.
+		//	returns:
+		//		The result of the evaluation. Often `undefined`
+	};
+
+	(Function("d", "d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo);
+
+
+	if(0){
+		dojo.exit = function(exitcode){
+			quit(exitcode);
+		};
+	} else{
+		dojo.exit = function(){
+		};
+	}
+
+	true || has.add("dojo-guarantee-console",
+		// ensure that console.log, console.warn, etc. are defined
+		1
+	);
+	if(1){
+		typeof console != "undefined" || (console = {});
+		//	Be careful to leave 'log' always at the end
+		var cn = [
+			"assert", "count", "debug", "dir", "dirxml", "error", "group",
+			"groupEnd", "info", "profile", "profileEnd", "time", "timeEnd",
+			"trace", "warn", "log"
+		];
+		var tn;
+		i = 0;
+		while((tn = cn[i++])){
+			if(!console[tn]){
+				(function(){
+					var tcn = tn + "";
+					console[tcn] = ('log' in console) ? function(){
+						var a = Array.apply({}, arguments);
+						a.unshift(tcn + ":");
+						console["log"](a.join(" "));
+					} : function(){};
+					console[tcn]._fake = true;
+				})();
+			}
+		}
+	}
+
+	has.add("dojo-debug-messages",
+		// include dojo.deprecated/dojo.experimental implementations
+		!!config.isDebug
+	);
+	if(has("dojo-debug-messages")){
+		dojo.deprecated = function(/*String*/ behaviour, /*String?*/ extra, /*String?*/ removal){
+			//	summary:
+			//		Log a debug message to indicate that a behavior has been
+			//		deprecated.
+			//	behaviour: String
+			//		The API or behavior being deprecated. Usually in the form
+			//		of "myApp.someFunction()".
+			//	extra: String?
+			//		Text to append to the message. Often provides advice on a
+			//		new function or facility to achieve the same goal during
+			//		the deprecation period.
+			//	removal: String?
+			//		Text to indicate when in the future the behavior will be
+			//		removed. Usually a version number.
+			//	example:
+			//	| dojo.deprecated("myApp.getTemp()", "use myApp.getLocaleTemp() instead", "1.0");
+
+			var message = "DEPRECATED: " + behaviour;
+			if(extra){ message += " " + extra; }
+			if(removal){ message += " -- will be removed in version: " + removal; }
+			console.warn(message);
+		};
+
+		dojo.experimental = function(/* String */ moduleName, /* String? */ extra){
+			//	summary: Marks code as experimental.
+			//	description:
+			//		This can be used to mark a function, file, or module as
+			//		experimental.	 Experimental code is not ready to be used, and the
+			//		APIs are subject to change without notice.	Experimental code may be
+			//		completed deleted without going through the normal deprecation
+			//		process.
+			//	moduleName: String
+			//		The name of a module, or the name of a module file or a specific
+			//		function
+			//	extra: String?
+			//		some additional message for the user
+			//	example:
+			//	| dojo.experimental("dojo.data.Result");
+			//	example:
+			//	| dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA");
+
+			var message = "EXPERIMENTAL: " + moduleName + " -- APIs subject to change without notice.";
+			if(extra){ message += " " + extra; }
+			console.warn(message);
+		};
+	}else{
+		dojo.deprecated = dojo.experimental =  function(){};
+	}
+
+	true || has.add("dojo-modulePaths",
+		// consume dojo.modulePaths processing
+		1
+	);
+	if(1){
+		// notice that modulePaths won't be applied to any require's before the dojo/_base/kernel factory is run;
+		// this is the v1.6- behavior.
+		if(config.modulePaths){
+			dojo.deprecated("dojo.modulePaths", "use paths configuration");
+			var paths = {};
+			for(p in config.modulePaths){
+				paths[p.replace(/\./g, "/")] = config.modulePaths[p];
+			}
+			require({paths:paths});
+		}
+	}
+
+	true || has.add("dojo-moduleUrl",
+		// include dojo.moduleUrl
+		1
+	);
+	if(1){
+		dojo.moduleUrl = function(/*String*/module, /*String?*/url){
+			//	summary:
+			//		Returns a URL relative to a module.
+			//	example:
+			//	|	var pngPath = dojo.moduleUrl("acme","images/small.png");
+			//	|	console.dir(pngPath); // list the object properties
+			//	|	// create an image and set it's source to pngPath's value:
+			//	|	var img = document.createElement("img");
+			//	|	img.src = pngPath;
+			//	|	// add our image to the document
+			//	|	dojo.body().appendChild(img);
+			//	example:
+			//		you may de-reference as far as you like down the package
+			//		hierarchy.  This is sometimes handy to avoid lenghty relative
+			//		urls or for building portable sub-packages. In this example,
+			//		the `acme.widget` and `acme.util` directories may be located
+			//		under different roots (see `dojo.registerModulePath`) but the
+			//		the modules which reference them can be unaware of their
+			//		relative locations on the filesystem:
+			//	|	// somewhere in a configuration block
+			//	|	dojo.registerModulePath("acme.widget", "../../acme/widget");
+			//	|	dojo.registerModulePath("acme.util", "../../util");
+			//	|
+			//	|	// ...
+			//	|
+			//	|	// code in a module using acme resources
+			//	|	var tmpltPath = dojo.moduleUrl("acme.widget","templates/template.html");
+			//	|	var dataPath = dojo.moduleUrl("acme.util","resources/data.json");
+
+			dojo.deprecated("dojo.moduleUrl()", "use require.toUrl", "2.0");
+
+			// require.toUrl requires a filetype; therefore, just append the suffix "/*.*" to guarantee a filetype, then
+			// remove the suffix from the result. This way clients can request a url w/out a filetype. This should be
+			// rare, but it maintains backcompat for the v1.x line (note: dojo.moduleUrl will be removed in v2.0).
+			// Notice * is an illegal filename so it won't conflict with any real path map that may exist the paths config.
+			var result = null;
+			if(module){
+				result = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : "") + "/*.*").replace(/\/\*\.\*/, "") + (url ? "" : "/");
+			}
+			return result;
+		};
+	}
+
+	dojo._hasResource = {}; // for backward compatibility with layers built with 1.6 tooling
+
+	return dojo;
+});