dojo-rails 0.9.8 → 0.9.9

data/vendor/assets/javascripts/dojo/data/util/simpleFetch.js.uncompressed.js

@@ -0,0 +1,95 @@
+define("dojo/data/util/simpleFetch", ["dojo/_base/lang", "dojo/_base/window", "./sorter"], 
+  function(lang, winUtil, sorter) {
+	// module:
+	//		dojo/data/util/simpleFetch
+	// summary:
+	//		TODOC
+
+var simpleFetch = lang.getObject("dojo.data.util.simpleFetch", true);
+
+simpleFetch.fetch = function(/* Object? */ request){
+	//	summary:
+	//		The simpleFetch mixin is designed to serve as a set of function(s) that can
+	//		be mixed into other datastore implementations to accelerate their development.
+	//		The simpleFetch mixin should work well for any datastore that can respond to a _fetchItems()
+	//		call by returning an array of all the found items that matched the query.  The simpleFetch mixin
+	//		is not designed to work for datastores that respond to a fetch() call by incrementally
+	//		loading items, or sequentially loading partial batches of the result
+	//		set.  For datastores that mixin simpleFetch, simpleFetch
+	//		implements a fetch method that automatically handles eight of the fetch()
+	//		arguments -- onBegin, onItem, onComplete, onError, start, count, sort and scope
+	//		The class mixing in simpleFetch should not implement fetch(),
+	//		but should instead implement a _fetchItems() method.  The _fetchItems()
+	//		method takes three arguments, the keywordArgs object that was passed
+	//		to fetch(), a callback function to be called when the result array is
+	//		available, and an error callback to be called if something goes wrong.
+	//		The _fetchItems() method should ignore any keywordArgs parameters for
+	//		start, count, onBegin, onItem, onComplete, onError, sort, and scope.
+	//		The _fetchItems() method needs to correctly handle any other keywordArgs
+	//		parameters, including the query parameter and any optional parameters
+	//		(such as includeChildren).  The _fetchItems() method should create an array of
+	//		result items and pass it to the fetchHandler along with the original request object
+	//		-- or, the _fetchItems() method may, if it wants to, create an new request object
+	//		with other specifics about the request that are specific to the datastore and pass
+	//		that as the request object to the handler.
+	//
+	//		For more information on this specific function, see dojo.data.api.Read.fetch()
+	request = request || {};
+	if(!request.store){
+		request.store = this;
+	}
+	var self = this;
+
+	var _errorHandler = function(errorData, requestObject){
+		if(requestObject.onError){
+			var scope = requestObject.scope || winUtil.global;
+			requestObject.onError.call(scope, errorData, requestObject);
+		}
+	};
+
+	var _fetchHandler = function(items, requestObject){
+		var oldAbortFunction = requestObject.abort || null;
+		var aborted = false;
+
+		var startIndex = requestObject.start?requestObject.start:0;
+		var endIndex = (requestObject.count && (requestObject.count !== Infinity))?(startIndex + requestObject.count):items.length;
+
+		requestObject.abort = function(){
+			aborted = true;
+			if(oldAbortFunction){
+				oldAbortFunction.call(requestObject);
+			}
+		};
+
+		var scope = requestObject.scope || winUtil.global;
+		if(!requestObject.store){
+			requestObject.store = self;
+		}
+		if(requestObject.onBegin){
+			requestObject.onBegin.call(scope, items.length, requestObject);
+		}
+		if(requestObject.sort){
+			items.sort(sorter.createSortFunction(requestObject.sort, self));
+		}
+		if(requestObject.onItem){
+			for(var i = startIndex; (i < items.length) && (i < endIndex); ++i){
+				var item = items[i];
+				if(!aborted){
+					requestObject.onItem.call(scope, item, requestObject);
+				}
+			}
+		}
+		if(requestObject.onComplete && !aborted){
+			var subset = null;
+			if(!requestObject.onItem){
+				subset = items.slice(startIndex, endIndex);
+			}
+			requestObject.onComplete.call(scope, subset, requestObject);
+		}
+	};
+	this._fetchItems(request, _fetchHandler, _errorHandler);
+	return request;	// Object
+};
+
+return simpleFetch;
+});

data/vendor/assets/javascripts/dojo/data/util/sorter.js

@@ -0,0 +1,66 @@
+/*
+	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/data/util/sorter",["dojo/_base/lang"],function(_1){
+var _2=_1.getObject("dojo.data.util.sorter",true);
+_2.basicComparator=function(a,b){
+var r=-1;
+if(a===null){
+a=undefined;
+}
+if(b===null){
+b=undefined;
+}
+if(a==b){
+r=0;
+}else{
+if(a>b||a==null){
+r=1;
+}
+}
+return r;
+};
+_2.createSortFunction=function(_3,_4){
+var _5=[];
+function _6(_7,_8,_9,s){
+return function(_a,_b){
+var a=s.getValue(_a,_7);
+var b=s.getValue(_b,_7);
+return _8*_9(a,b);
+};
+};
+var _c;
+var _d=_4.comparatorMap;
+var bc=_2.basicComparator;
+for(var i=0;i<_3.length;i++){
+_c=_3[i];
+var _e=_c.attribute;
+if(_e){
+var _f=(_c.descending)?-1:1;
+var _10=bc;
+if(_d){
+if(typeof _e!=="string"&&("toString" in _e)){
+_e=_e.toString();
+}
+_10=_d[_e]||bc;
+}
+_5.push(_6(_e,_f,_10,_4));
+}
+}
+return function(_11,_12){
+var i=0;
+while(i<_5.length){
+var ret=_5[i++](_11,_12);
+if(ret!==0){
+return ret;
+}
+}
+return 0;
+};
+};
+return _2;
+});

data/vendor/assets/javascripts/dojo/data/util/sorter.js.uncompressed.js

@@ -0,0 +1,99 @@
+define("dojo/data/util/sorter", ["dojo/_base/lang"], function(lang) {
+	// module:
+	//		dojo/data/util/sorter
+	// summary:
+	//		TODOC
+
+var sorter = lang.getObject("dojo.data.util.sorter", true);
+
+sorter.basicComparator = function(	/*anything*/ a,
+													/*anything*/ b){
+	//	summary:
+	//		Basic comparision function that compares if an item is greater or less than another item
+	//	description:
+	//		returns 1 if a > b, -1 if a < b, 0 if equal.
+	//		'null' values (null, undefined) are treated as larger values so that they're pushed to the end of the list.
+	//		And compared to each other, null is equivalent to undefined.
+
+	//null is a problematic compare, so if null, we set to undefined.
+	//Makes the check logic simple, compact, and consistent
+	//And (null == undefined) === true, so the check later against null
+	//works for undefined and is less bytes.
+	var r = -1;
+	if(a === null){
+		a = undefined;
+	}
+	if(b === null){
+		b = undefined;
+	}
+	if(a == b){
+		r = 0;
+	}else if(a > b || a == null){
+		r = 1;
+	}
+	return r; //int {-1,0,1}
+};
+
+sorter.createSortFunction = function(	/* attributes array */sortSpec, /*dojo.data.core.Read*/ store){
+	//	summary:
+	//		Helper function to generate the sorting function based off the list of sort attributes.
+	//	description:
+	//		The sort function creation will look for a property on the store called 'comparatorMap'.  If it exists
+	//		it will look in the mapping for comparisons function for the attributes.  If one is found, it will
+	//		use it instead of the basic comparator, which is typically used for strings, ints, booleans, and dates.
+	//		Returns the sorting function for this particular list of attributes and sorting directions.
+	//
+	//	sortSpec: array
+	//		A JS object that array that defines out what attribute names to sort on and whether it should be descenting or asending.
+	//		The objects should be formatted as follows:
+	//		{
+	//			attribute: "attributeName-string" || attribute,
+	//			descending: true|false;   // Default is false.
+	//		}
+	//	store: object
+	//		The datastore object to look up item values from.
+	//
+	var sortFunctions=[];
+
+	function createSortFunction(attr, dir, comp, s){
+		//Passing in comp and s (comparator and store), makes this
+		//function much faster.
+		return function(itemA, itemB){
+			var a = s.getValue(itemA, attr);
+			var b = s.getValue(itemB, attr);
+			return dir * comp(a,b); //int
+		};
+	}
+	var sortAttribute;
+	var map = store.comparatorMap;
+	var bc = sorter.basicComparator;
+	for(var i = 0; i < sortSpec.length; i++){
+		sortAttribute = sortSpec[i];
+		var attr = sortAttribute.attribute;
+		if(attr){
+			var dir = (sortAttribute.descending) ? -1 : 1;
+			var comp = bc;
+			if(map){
+				if(typeof attr !== "string" && ("toString" in attr)){
+					 attr = attr.toString();
+				}
+				comp = map[attr] || bc;
+			}
+			sortFunctions.push(createSortFunction(attr,
+				dir, comp, store));
+		}
+	}
+	return function(rowA, rowB){
+		var i=0;
+		while(i < sortFunctions.length){
+			var ret = sortFunctions[i++](rowA, rowB);
+			if(ret !== 0){
+				return ret;//int
+			}
+		}
+		return 0; //int
+	}; // Function
+};
+
+return sorter;
+});

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

@@ -0,0 +1,213 @@
+/*
+	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/date",["./_base/kernel","./_base/lang"],function(_1,_2){
+_2.getObject("date",true,_1);
+_1.date.getDaysInMonth=function(_3){
+var _4=_3.getMonth();
+var _5=[31,28,31,30,31,30,31,31,30,31,30,31];
+if(_4==1&&_1.date.isLeapYear(_3)){
+return 29;
+}
+return _5[_4];
+};
+_1.date.isLeapYear=function(_6){
+var _7=_6.getFullYear();
+return !(_7%400)||(!(_7%4)&&!!(_7%100));
+};
+_1.date.getTimezoneName=function(_8){
+var _9=_8.toString();
+var tz="";
+var _a;
+var _b=_9.indexOf("(");
+if(_b>-1){
+tz=_9.substring(++_b,_9.indexOf(")"));
+}else{
+var _c=/([A-Z\/]+) \d{4}$/;
+if((_a=_9.match(_c))){
+tz=_a[1];
+}else{
+_9=_8.toLocaleString();
+_c=/ ([A-Z\/]+)$/;
+if((_a=_9.match(_c))){
+tz=_a[1];
+}
+}
+}
+return (tz=="AM"||tz=="PM")?"":tz;
+};
+_1.date.compare=function(_d,_e,_f){
+_d=new Date(+_d);
+_e=new Date(+(_e||new Date()));
+if(_f=="date"){
+_d.setHours(0,0,0,0);
+_e.setHours(0,0,0,0);
+}else{
+if(_f=="time"){
+_d.setFullYear(0,0,0);
+_e.setFullYear(0,0,0);
+}
+}
+if(_d>_e){
+return 1;
+}
+if(_d<_e){
+return -1;
+}
+return 0;
+};
+_1.date.add=function(_10,_11,_12){
+var sum=new Date(+_10);
+var _13=false;
+var _14="Date";
+switch(_11){
+case "day":
+break;
+case "weekday":
+var _15,_16;
+var mod=_12%5;
+if(!mod){
+_15=(_12>0)?5:-5;
+_16=(_12>0)?((_12-5)/5):((_12+5)/5);
+}else{
+_15=mod;
+_16=parseInt(_12/5);
+}
+var _17=_10.getDay();
+var adj=0;
+if(_17==6&&_12>0){
+adj=1;
+}else{
+if(_17==0&&_12<0){
+adj=-1;
+}
+}
+var _18=_17+_15;
+if(_18==0||_18==6){
+adj=(_12>0)?2:-2;
+}
+_12=(7*_16)+_15+adj;
+break;
+case "year":
+_14="FullYear";
+_13=true;
+break;
+case "week":
+_12*=7;
+break;
+case "quarter":
+_12*=3;
+case "month":
+_13=true;
+_14="Month";
+break;
+default:
+_14="UTC"+_11.charAt(0).toUpperCase()+_11.substring(1)+"s";
+}
+if(_14){
+sum["set"+_14](sum["get"+_14]()+_12);
+}
+if(_13&&(sum.getDate()<_10.getDate())){
+sum.setDate(0);
+}
+return sum;
+};
+_1.date.difference=function(_19,_1a,_1b){
+_1a=_1a||new Date();
+_1b=_1b||"day";
+var _1c=_1a.getFullYear()-_19.getFullYear();
+var _1d=1;
+switch(_1b){
+case "quarter":
+var m1=_19.getMonth();
+var m2=_1a.getMonth();
+var q1=Math.floor(m1/3)+1;
+var q2=Math.floor(m2/3)+1;
+q2+=(_1c*4);
+_1d=q2-q1;
+break;
+case "weekday":
+var _1e=Math.round(_1.date.difference(_19,_1a,"day"));
+var _1f=parseInt(_1.date.difference(_19,_1a,"week"));
+var mod=_1e%7;
+if(mod==0){
+_1e=_1f*5;
+}else{
+var adj=0;
+var _20=_19.getDay();
+var _21=_1a.getDay();
+_1f=parseInt(_1e/7);
+mod=_1e%7;
+var _22=new Date(_19);
+_22.setDate(_22.getDate()+(_1f*7));
+var _23=_22.getDay();
+if(_1e>0){
+switch(true){
+case _20==6:
+adj=-1;
+break;
+case _20==0:
+adj=0;
+break;
+case _21==6:
+adj=-1;
+break;
+case _21==0:
+adj=-2;
+break;
+case (_23+mod)>5:
+adj=-2;
+}
+}else{
+if(_1e<0){
+switch(true){
+case _20==6:
+adj=0;
+break;
+case _20==0:
+adj=1;
+break;
+case _21==6:
+adj=2;
+break;
+case _21==0:
+adj=1;
+break;
+case (_23+mod)<0:
+adj=2;
+}
+}
+}
+_1e+=adj;
+_1e-=(_1f*2);
+}
+_1d=_1e;
+break;
+case "year":
+_1d=_1c;
+break;
+case "month":
+_1d=(_1a.getMonth()-_19.getMonth())+(_1c*12);
+break;
+case "week":
+_1d=parseInt(_1.date.difference(_19,_1a,"day")/7);
+break;
+case "day":
+_1d/=24;
+case "hour":
+_1d/=60;
+case "minute":
+_1d/=60;
+case "second":
+_1d/=1000;
+case "millisecond":
+_1d*=_1a.getTime()-_19.getTime();
+}
+return Math.round(_1d);
+};
+return _1.date;
+});