dojo-rails 0.9.9 → 0.9.10

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

@@ -1,16 +1,73 @@
-define("dojo/data/util/simpleFetch", ["dojo/_base/lang", "dojo/_base/window", "./sorter"], 
-  function(lang, winUtil, sorter) {
+define("dojo/data/util/simpleFetch", ["../../_base/lang", "../../_base/kernel", "./sorter"],
+  function(lang, kernel, sorter){
 	// module:
 	//		dojo/data/util/simpleFetch
 	// summary:
-	//		TODOC
+	//		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.
+
+var simpleFetch = {};
+lang.setObject("dojo.data.util.simpleFetch", simpleFetch);
+
+simpleFetch.errorHandler = function(/*Object*/ errorData, /*Object*/ requestObject){
+	// summary:
+	//		The error handler when there is an error fetching items.  This function should not be called
+	//		directly and is used by simpleFetch.fetch().
+	if(requestObject.onError){
+		var scope = requestObject.scope || kernel.global;
+		requestObject.onError.call(scope, errorData, requestObject);
+	}
+};
+
+simpleFetch.fetchHandler = function(/*Array*/ items, /*Object*/ requestObject){
+	// summary:
+	//		The handler when items are sucessfully fetched.  This function should not be called directly
+	//		and is used by simpleFetch.fetch().
+	var oldAbortFunction = requestObject.abort || null,
+		aborted = false,
+
+		startIndex = requestObject.start?requestObject.start: 0,
+		endIndex = (requestObject.count && (requestObject.count !== Infinity))?(startIndex + requestObject.count):items.length;
+
+	requestObject.abort = function(){
+		aborted = true;
+		if(oldAbortFunction){
+			oldAbortFunction.call(requestObject);
+		}
+	};
 
-var simpleFetch = lang.getObject("dojo.data.util.simpleFetch", true);
+	var scope = requestObject.scope || kernel.global;
+	if(!requestObject.store){
+		requestObject.store = this;
+	}
+	if(requestObject.onBegin){
+		requestObject.onBegin.call(scope, items.length, requestObject);
+	}
+	if(requestObject.sort){
+		items.sort(sorter.createSortFunction(requestObject.sort, this));
+	}
+	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);
+	}
+};
 
 simpleFetch.fetch = function(/* Object? */ request){
-	//	summary:
+	// 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.
+	// description:
 	//		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
@@ -28,66 +85,154 @@ simpleFetch.fetch = function(/* Object? */ request){
 	//		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
+	//		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()
+	//		For more information on this specific function, see dojo/data/api/Read.fetch()
+	//
+	// request:
+	//		The keywordArgs parameter may either be an instance of
+	//		conforming to dojo/data/api/Request or may be a simple anonymous object
+	//		that may contain any of the following:
+	// |	{
+	// |		query: query-object or query-string,
+	// |		queryOptions: object,
+	// |		onBegin: Function,
+	// |		onItem: Function,
+	// |		onComplete: Function,
+	// |		onError: Function,
+	// |		scope: object,
+	// |		start: int
+	// |		count: int
+	// |		sort: array
+	// |	}
+	//		All implementations should accept keywordArgs objects with any of
+	//		the 9 standard properties: query, onBegin, onItem, onComplete, onError
+	//		scope, sort, start, and count.  Some implementations may accept additional
+	//		properties in the keywordArgs object as valid parameters, such as
+	//		{includeOutliers:true}.
+	//
+	//		####The *query* parameter
+	//
+	//		The query may be optional in some data store implementations.
+	//		The dojo/data/api/Read API does not specify the syntax or semantics
+	//		of the query itself -- each different data store implementation
+	//		may have its own notion of what a query should look like.
+	//		However, as of dojo 0.9, 1.0, and 1.1, all the provided datastores in dojo.data
+	//		and dojox.data support an object structure query, where the object is a set of
+	//		name/value parameters such as { attrFoo: valueBar, attrFoo1: valueBar1}.  Most of the
+	//		dijit widgets, such as ComboBox assume this to be the case when working with a datastore
+	//		when they dynamically update the query.  Therefore, for maximum compatibility with dijit
+	//		widgets the recommended query parameter is a key/value object.  That does not mean that the
+	//		the datastore may not take alternative query forms, such as a simple string, a Date, a number,
+	//		or a mix of such.  Ultimately, The dojo/data/api/Read API is agnostic about what the query
+	//		format.
+	//
+	//		Further note:  In general for query objects that accept strings as attribute
+	//		value matches, the store should also support basic filtering capability, such as *
+	//		(match any character) and ? (match single character).  An example query that is a query object
+	//		would be like: { attrFoo: "value*"}.  Which generally means match all items where they have
+	//		an attribute named attrFoo, with a value that starts with 'value'.
+	//
+	//		####The *queryOptions* parameter
+	//
+	//		The queryOptions parameter is an optional parameter used to specify options that may modify
+	//		the query in some fashion, such as doing a case insensitive search, or doing a deep search
+	//		where all items in a hierarchical representation of data are scanned instead of just the root
+	//		items.  It currently defines two options that all datastores should attempt to honor if possible:
+	// |	{
+	// |		ignoreCase: boolean, // Whether or not the query should match case sensitively or not.  Default behaviour is false.
+	// |		deep: boolean	// Whether or not a fetch should do a deep search of items and all child
+	// |						// items instead of just root-level items in a datastore.  Default is false.
+	// |	}
+	//
+	//		####The *onBegin* parameter.
+	//
+	//		function(size, request);
+	//		If an onBegin callback function is provided, the callback function
+	//		will be called just once, before the first onItem callback is called.
+	//		The onBegin callback function will be passed two arguments, the
+	//		the total number of items identified and the Request object.  If the total number is
+	//		unknown, then size will be -1.  Note that size is not necessarily the size of the
+	//		collection of items returned from the query, as the request may have specified to return only a
+	//		subset of the total set of items through the use of the start and count parameters.
+	//
+	//		####The *onItem* parameter.
+	//
+	//		function(item, request);
+	//
+	//		If an onItem callback function is provided, the callback function
+	//		will be called as each item in the result is received. The callback
+	//		function will be passed two arguments: the item itself, and the
+	//		Request object.
+	//
+	//		####The *onComplete* parameter.
+	//
+	//		function(items, request);
+	//
+	//		If an onComplete callback function is provided, the callback function
+	//		will be called just once, after the last onItem callback is called.
+	//		Note that if the onItem callback is not present, then onComplete will be passed
+	//		an array containing all items which matched the query and the request object.
+	//		If the onItem callback is present, then onComplete is called as:
+	//		onComplete(null, request).
+	//
+	//		####The *onError* parameter.
+	//
+	//		function(errorData, request);
+	//
+	//		If an onError callback function is provided, the callback function
+	//		will be called if there is any sort of error while attempting to
+	//		execute the query.
+	//		The onError callback function will be passed two arguments:
+	//		an Error object and the Request object.
+	//
+	//		####The *scope* parameter.
+	//
+	//		If a scope object is provided, all of the callback functions (onItem,
+	//		onComplete, onError, etc) will be invoked in the context of the scope
+	//		object.  In the body of the callback function, the value of the "this"
+	//		keyword will be the scope object.   If no scope object is provided,
+	//		the callback functions will be called in the context of dojo.global().
+	//		For example, onItem.call(scope, item, request) vs.
+	//		onItem.call(dojo.global(), item, request)
+	//
+	//		####The *start* parameter.
+	//
+	//		If a start parameter is specified, this is a indication to the datastore to
+	//		only start returning items once the start number of items have been located and
+	//		skipped.  When this parameter is paired with 'count', the store should be able
+	//		to page across queries with millions of hits by only returning subsets of the
+	//		hits for each query
+	//
+	//		####The *count* parameter.
+	//
+	//		If a count parameter is specified, this is a indication to the datastore to
+	//		only return up to that many items.  This allows a fetch call that may have
+	//		millions of item matches to be paired down to something reasonable.
+	//
+	//		####The *sort* parameter.
+	//
+	//		If a sort parameter is specified, this is a indication to the datastore to
+	//		sort the items in some manner before returning the items.  The array is an array of
+	//		javascript objects that must conform to the following format to be applied to the
+	//		fetching of items:
+	// |	{
+	// |		attribute: attribute || attribute-name-string,
+	// |		descending: true|false;   // Optional.  Default is false.
+	// |	}
+	//		Note that when comparing attributes, if an item contains no value for the attribute
+	//		(undefined), then it the default ascending sort logic should push it to the bottom
+	//		of the list.  In the descending order case, it such items should appear at the top of the list.
+
 	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);
+	this._fetchItems(request, lang.hitch(this, "fetchHandler"), lang.hitch(this, "errorHandler"));
 	return request;	// Object
 };
 

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

@@ -5,8 +5,9 @@
 */
 
 //>>built
-define("dojo/data/util/sorter",["dojo/_base/lang"],function(_1){
-var _2=_1.getObject("dojo.data.util.sorter",true);
+define("dojo/data/util/sorter",["../../_base/lang"],function(_1){
+var _2={};
+_1.setObject("dojo.data.util.sorter",_2);
 _2.basicComparator=function(a,b){
 var r=-1;
 if(a===null){

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

@@ -1,16 +1,17 @@
-define("dojo/data/util/sorter", ["dojo/_base/lang"], function(lang) {
+define("dojo/data/util/sorter", ["../../_base/lang"], function(lang){
 	// module:
 	//		dojo/data/util/sorter
 	// summary:
 	//		TODOC
 
-var sorter = lang.getObject("dojo.data.util.sorter", true);
+var sorter = {};
+lang.setObject("dojo.data.util.sorter", sorter);
 
 sorter.basicComparator = function(	/*anything*/ a,
 													/*anything*/ b){
-	//	summary:
-	//		Basic comparision function that compares if an item is greater or less than another item
-	//	description:
+	// summary:
+	//		Basic comparison 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.
@@ -34,25 +35,24 @@ sorter.basicComparator = function(	/*anything*/ a,
 	return r; //int {-1,0,1}
 };
 
-sorter.createSortFunction = function(	/* attributes array */sortSpec, /*dojo.data.core.Read*/ store){
-	//	summary:
+sorter.createSortFunction = function(	/* attributes[] */sortSpec, /*dojo/data/api/Read*/ store){
+	// summary:
 	//		Helper function to generate the sorting function based off the list of sort attributes.
-	//	description:
+	// 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
+	// sortSpec:
 	//		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
+	// |	{
+	// |		attribute: "attributeName-string" || attribute,
+	// |		descending: true|false;   // Default is false.
+	// |	}
+	// store:
 	//		The datastore object to look up item values from.
-	//
+
 	var sortFunctions=[];
 
 	function createSortFunction(attr, dir, comp, s){

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

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