dojo-rails 0.9.8 → 0.9.9

data/vendor/assets/javascripts/dojo/store/util/QueryResults.js

@@ -0,0 +1,39 @@
+/*
+	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/store/util/QueryResults",["../../_base/array","../../_base/lang","../../_base/Deferred"],function(_1,_2,_3){
+var _4=_2.getObject("dojo.store.util",true);
+_4.QueryResults=function(_5){
+if(!_5){
+return _5;
+}
+if(_5.then){
+_5=_2.delegate(_5);
+}
+function _6(_7){
+if(!_5[_7]){
+_5[_7]=function(){
+var _8=arguments;
+return _3.when(_5,function(_9){
+Array.prototype.unshift.call(_8,_9);
+return _4.QueryResults(_1[_7].apply(_1,_8));
+});
+};
+}
+};
+_6("forEach");
+_6("filter");
+_6("map");
+if(!_5.total){
+_5.total=_3.when(_5,function(_a){
+return _a.length;
+});
+}
+return _5;
+};
+return _4.QueryResults;
+});

data/vendor/assets/javascripts/dojo/store/util/QueryResults.js.uncompressed.js

@@ -0,0 +1,64 @@
+define("dojo/store/util/QueryResults", ["../../_base/array", "../../_base/lang", "../../_base/Deferred"
+], function(array, lang, Deferred) {
+  //  module:
+  //    dojo/store/util/QueryResults
+  //  summary:
+  //    The module defines a query results wrapper
+
+var util = lang.getObject("dojo.store.util", true);
+
+util.QueryResults = function(results){
+	// summary:
+	//		A function that wraps the results of a store query with additional
+	//		methods.
+	//
+	// description:
+	//		QueryResults is a basic wrapper that allows for array-like iteration
+	//		over any kind of returned data from a query.  While the simplest store
+	//		will return a plain array of data, other stores may return deferreds or
+	//		promises; this wrapper makes sure that *all* results can be treated
+	//		the same.
+	//
+	//		Additional methods include `forEach`, `filter` and `map`.
+	//
+	// returns: Object
+	//		An array-like object that can be used for iterating over.
+	//
+	// example:
+	//		Query a store and iterate over the results.
+	//
+	//	|	store.query({ prime: true }).forEach(function(item){
+	//	|		//	do something
+	//	|	});
+
+	if(!results){
+		return results;
+	}
+	// if it is a promise it may be frozen
+	if(results.then){
+		results = lang.delegate(results);
+	}
+	function addIterativeMethod(method){
+		if(!results[method]){
+			results[method] = function(){
+				var args = arguments;
+				return Deferred.when(results, function(results){
+					Array.prototype.unshift.call(args, results);
+					return util.QueryResults(array[method].apply(array, args));
+				});
+			};
+		}
+	}
+	addIterativeMethod("forEach");
+	addIterativeMethod("filter");
+	addIterativeMethod("map");
+	if(!results.total){
+		results.total = Deferred.when(results, function(results){
+			return results.length;
+		});
+	}
+	return results;
+};
+
+return util.QueryResults;
+});

data/vendor/assets/javascripts/dojo/store/util/SimpleQueryEngine.js

@@ -0,0 +1,63 @@
+/*
+	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/store/util/SimpleQueryEngine",["../../_base/array"],function(_1){
+return function(_2,_3){
+switch(typeof _2){
+default:
+throw new Error("Can not query with a "+typeof _2);
+case "object":
+case "undefined":
+var _4=_2;
+_2=function(_5){
+for(var _6 in _4){
+var _7=_4[_6];
+if(_7&&_7.test){
+if(!_7.test(_5[_6])){
+return false;
+}
+}else{
+if(_7!=_5[_6]){
+return false;
+}
+}
+}
+return true;
+};
+break;
+case "string":
+if(!this[_2]){
+throw new Error("No filter function "+_2+" was found in store");
+}
+_2=this[_2];
+case "function":
+}
+function _8(_9){
+var _a=_1.filter(_9,_2);
+if(_3&&_3.sort){
+_a.sort(function(a,b){
+for(var _b,i=0;_b=_3.sort[i];i++){
+var _c=a[_b.attribute];
+var _d=b[_b.attribute];
+if(_c!=_d){
+return !!_b.descending==_c>_d?-1:1;
+}
+}
+return 0;
+});
+}
+if(_3&&(_3.start||_3.count)){
+var _e=_a.length;
+_a=_a.slice(_3.start||0,(_3.start||0)+(_3.count||Infinity));
+_a.total=_e;
+}
+return _a;
+};
+_8.matches=_2;
+return _8;
+};
+});

data/vendor/assets/javascripts/dojo/store/util/SimpleQueryEngine.js.uncompressed.js

@@ -0,0 +1,108 @@
+define("dojo/store/util/SimpleQueryEngine", ["../../_base/array"], function(arrayUtil) {
+  //  module:
+  //    dojo/store/util/SimpleQueryEngine
+  //  summary:
+  //    The module defines a simple filtering query engine for object stores. 
+
+return function(query, options){
+	// summary:
+	//		Simple query engine that matches using filter functions, named filter
+	//		functions or objects by name-value on a query object hash
+	//
+	// description:
+	//		The SimpleQueryEngine provides a way of getting a QueryResults through
+	//		the use of a simple object hash as a filter.  The hash will be used to
+	//		match properties on data objects with the corresponding value given. In
+	//		other words, only exact matches will be returned.
+	//
+	//		This function can be used as a template for more complex query engines;
+	//		for example, an engine can be created that accepts an object hash that
+	//		contains filtering functions, or a string that gets evaluated, etc.
+	//
+	//		When creating a new dojo.store, simply set the store's queryEngine
+	//		field as a reference to this function.
+	//
+	// query: Object
+	//		An object hash with fields that may match fields of items in the store.
+	//		Values in the hash will be compared by normal == operator, but regular expressions
+	//		or any object that provides a test() method are also supported and can be
+	// 		used to match strings by more complex expressions
+	// 		(and then the regex's or object's test() method will be used to match values).
+	//
+	// options: dojo.store.util.SimpleQueryEngine.__queryOptions?
+	//		An object that contains optional information such as sort, start, and count.
+	//
+	// returns: Function
+	//		A function that caches the passed query under the field "matches".  See any
+	//		of the "query" methods on dojo.stores.
+	//
+	// example:
+	//		Define a store with a reference to this engine, and set up a query method.
+	//
+	//	|	var myStore = function(options){
+	//	|		//	...more properties here
+	//	|		this.queryEngine = dojo.store.util.SimpleQueryEngine;
+	//	|		//	define our query method
+	//	|		this.query = function(query, options){
+	//	|			return dojo.store.util.QueryResults(this.queryEngine(query, options)(this.data));
+	//	|		};
+	//	|	};
+
+	// create our matching query function
+	switch(typeof query){
+		default:
+			throw new Error("Can not query with a " + typeof query);
+		case "object": case "undefined":
+			var queryObject = query;
+			query = function(object){
+				for(var key in queryObject){
+					var required = queryObject[key];
+					if(required && required.test){
+						if(!required.test(object[key])){
+							return false;
+						}
+					}else if(required != object[key]){
+						return false;
+					}
+				}
+				return true;
+			};
+			break;
+		case "string":
+			// named query
+			if(!this[query]){
+				throw new Error("No filter function " + query + " was found in store");
+			}
+			query = this[query];
+			// fall through
+		case "function":
+			// fall through
+	}
+	function execute(array){
+		// execute the whole query, first we filter
+		var results = arrayUtil.filter(array, query);
+		// next we sort
+		if(options && options.sort){
+			results.sort(function(a, b){
+				for(var sort, i=0; sort = options.sort[i]; i++){
+					var aValue = a[sort.attribute];
+					var bValue = b[sort.attribute];
+					if (aValue != bValue) {
+						return !!sort.descending == aValue > bValue ? -1 : 1;
+					}
+				}
+				return 0;
+			});
+		}
+		// now we paginate
+		if(options && (options.start || options.count)){
+			var total = results.length;
+			results = results.slice(options.start || 0, (options.start || 0) + (options.count || Infinity));
+			results.total = total;
+		}
+		return results;
+	}
+	execute.matches = query;
+	return execute;
+};
+});

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

@@ -0,0 +1,57 @@
+/*
+	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/string",["./_base/kernel","./_base/lang"],function(_1,_2){
+_2.getObject("string",true,_1);
+_1.string.rep=function(_3,_4){
+if(_4<=0||!_3){
+return "";
+}
+var _5=[];
+for(;;){
+if(_4&1){
+_5.push(_3);
+}
+if(!(_4>>=1)){
+break;
+}
+_3+=_3;
+}
+return _5.join("");
+};
+_1.string.pad=function(_6,_7,ch,_8){
+if(!ch){
+ch="0";
+}
+var _9=String(_6),_a=_1.string.rep(ch,Math.ceil((_7-_9.length)/ch.length));
+return _8?_9+_a:_a+_9;
+};
+_1.string.substitute=function(_b,_c,_d,_e){
+_e=_e||_1.global;
+_d=_d?_2.hitch(_e,_d):function(v){
+return v;
+};
+return _b.replace(/\$\{([^\s\:\}]+)(?:\:([^\s\:\}]+))?\}/g,function(_f,key,_10){
+var _11=_2.getObject(key,false,_c);
+if(_10){
+_11=_2.getObject(_10,false,_e).call(_e,_11,key);
+}
+return _d(_11,key).toString();
+});
+};
+_1.string.trim=String.prototype.trim?_2.trim:function(str){
+str=str.replace(/^\s+/,"");
+for(var i=str.length-1;i>=0;i--){
+if(/\S/.test(str.charAt(i))){
+str=str.substring(0,i+1);
+break;
+}
+}
+return str;
+};
+return _1.string;
+});

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

@@ -0,0 +1,162 @@
+define("dojo/string", ["./_base/kernel", "./_base/lang"], function(dojo, lang) {
+	// module:
+	//		dojo/string
+	// summary:
+	//		TODOC
+
+lang.getObject("string", true, dojo);
+
+/*=====
+dojo.string = {
+	// summary: String utilities for Dojo
+};
+=====*/
+
+dojo.string.rep = function(/*String*/str, /*Integer*/num){
+	// summary:
+	//		Efficiently replicate a string `n` times.
+	// str:
+	//		the string to replicate
+	// num:
+	//		number of times to replicate the string
+
+	if(num <= 0 || !str){ return ""; }
+
+	var buf = [];
+	for(;;){
+		if(num & 1){
+			buf.push(str);
+		}
+		if(!(num >>= 1)){ break; }
+		str += str;
+	}
+	return buf.join("");	// String
+};
+
+dojo.string.pad = function(/*String*/text, /*Integer*/size, /*String?*/ch, /*Boolean?*/end){
+	// summary:
+	//		Pad a string to guarantee that it is at least `size` length by
+	//		filling with the character `ch` at either the start or end of the
+	//		string. Pads at the start, by default.
+	// text:
+	//		the string to pad
+	// size:
+	//		length to provide padding
+	// ch:
+	//		character to pad, defaults to '0'
+	// end:
+	//		adds padding at the end if true, otherwise pads at start
+	// example:
+	//	|	// Fill the string to length 10 with "+" characters on the right.  Yields "Dojo++++++".
+	//	|	dojo.string.pad("Dojo", 10, "+", true);
+
+	if(!ch){
+		ch = '0';
+	}
+	var out = String(text),
+		pad = dojo.string.rep(ch, Math.ceil((size - out.length) / ch.length));
+	return end ? out + pad : pad + out;	// String
+};
+
+dojo.string.substitute = function(	/*String*/		template,
+									/*Object|Array*/map,
+									/*Function?*/	transform,
+									/*Object?*/		thisObject){
+	// summary:
+	//		Performs parameterized substitutions on a string. Throws an
+	//		exception if any parameter is unmatched.
+	// template:
+	//		a string with expressions in the form `${key}` to be replaced or
+	//		`${key:format}` which specifies a format function. keys are case-sensitive.
+	// map:
+	//		hash to search for substitutions
+	// transform:
+	//		a function to process all parameters before substitution takes
+	//		place, e.g. mylib.encodeXML
+	// thisObject:
+	//		where to look for optional format function; default to the global
+	//		namespace
+	// example:
+	//		Substitutes two expressions in a string from an Array or Object
+	//	|	// returns "File 'foo.html' is not found in directory '/temp'."
+	//	|	// by providing substitution data in an Array
+	//	|	dojo.string.substitute(
+	//	|		"File '${0}' is not found in directory '${1}'.",
+	//	|		["foo.html","/temp"]
+	//	|	);
+	//	|
+	//	|	// also returns "File 'foo.html' is not found in directory '/temp'."
+	//	|	// but provides substitution data in an Object structure.  Dotted
+	//	|	// notation may be used to traverse the structure.
+	//	|	dojo.string.substitute(
+	//	|		"File '${name}' is not found in directory '${info.dir}'.",
+	//	|		{ name: "foo.html", info: { dir: "/temp" } }
+	//	|	);
+	// example:
+	//		Use a transform function to modify the values:
+	//	|	// returns "file 'foo.html' is not found in directory '/temp'."
+	//	|	dojo.string.substitute(
+	//	|		"${0} is not found in ${1}.",
+	//	|		["foo.html","/temp"],
+	//	|		function(str){
+	//	|			// try to figure out the type
+	//	|			var prefix = (str.charAt(0) == "/") ? "directory": "file";
+	//	|			return prefix + " '" + str + "'";
+	//	|		}
+	//	|	);
+	// example:
+	//		Use a formatter
+	//	|	// returns "thinger -- howdy"
+	//	|	dojo.string.substitute(
+	//	|		"${0:postfix}", ["thinger"], null, {
+	//	|			postfix: function(value, key){
+	//	|				return value + " -- howdy";
+	//	|			}
+	//	|		}
+	//	|	);
+
+	thisObject = thisObject || dojo.global;
+	transform = transform ?
+		lang.hitch(thisObject, transform) : function(v){ return v; };
+
+	return template.replace(/\$\{([^\s\:\}]+)(?:\:([^\s\:\}]+))?\}/g,
+		function(match, key, format){
+			var value = lang.getObject(key, false, map);
+			if(format){
+				value = lang.getObject(format, false, thisObject).call(thisObject, value, key);
+			}
+			return transform(value, key).toString();
+		}); // String
+};
+
+/*=====
+dojo.string.trim = function(str){
+	// summary:
+	//		Trims whitespace from both sides of the string
+	// str: String
+	//		String to be trimmed
+	// returns: String
+	//		Returns the trimmed string
+	// description:
+	//		This version of trim() was taken from [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript).
+	//		The short yet performant version of this function is dojo.trim(),
+	//		which is part of Dojo base.  Uses String.prototype.trim instead, if available.
+	return "";	// String
+}
+=====*/
+
+dojo.string.trim = String.prototype.trim ?
+	lang.trim : // aliasing to the native function
+	function(str){
+		str = str.replace(/^\s+/, '');
+		for(var i = str.length - 1; i >= 0; i--){
+			if(/\S/.test(str.charAt(i))){
+				str = str.substring(0, i + 1);
+				break;
+			}
+		}
+		return str;
+	};
+
+return dojo.string;
+});