dojo-rails 0.11.0 → 0.14.0

data/vendor/assets/javascripts/dojo/data/api/Request.js.uncompressed.js

@@ -1,33 +0,0 @@
-define("dojo/data/api/Request", ["../../_base/declare"], function(declare){
-
-// module:
-//		dojo/data/api/Request
-
-return declare("dojo.data.api.Request", null, {
-	// summary:
-	//		This class defines out the semantics of what a 'Request' object looks like
-	//		when returned from a fetch() method.  In general, a request object is
-	//		nothing more than the original keywordArgs from fetch with an abort function
-	//		attached to it to allow users to abort a particular request if they so choose.
-	//		No other functions are required on a general Request object return.  That does not
-	//		inhibit other store implementations from adding extensions to it, of course.
-	//
-	//		This is an abstract API that data provider implementations conform to.
-	//		This file defines methods signatures and intentionally leaves all the
-	//		methods unimplemented.
-	//
-	//		For more details on fetch, see dojo/data/api/Read.fetch().
-
-	abort: function(){
-		// summary:
-		//		This function is a hook point for stores to provide as a way for
-		//		a fetch to be halted mid-processing.
-		// description:
-		//		This function is a hook point for stores to provide as a way for
-		//		a fetch to be halted mid-processing.  For more details on the fetch() api,
-		//		please see dojo/data/api/Read.fetch().
-		throw new Error('Unimplemented API: dojo.data.api.Request.abort');
-	}
-});
-
-});

data/vendor/assets/javascripts/dojo/data/api/Write.js.uncompressed.js

@@ -1,206 +0,0 @@
-define("dojo/data/api/Write", ["../../_base/declare", "./Read"], function(declare, Read){
-
-// module:
-//		dojo/data/api/Write
-
-return declare("dojo.data.api.Write", Read, {
-	// summary:
-	//		This is an abstract API that data provider implementations conform to.
-	//		This file defines function signatures and intentionally leaves all the
-	//		functions unimplemented.
-
-	getFeatures: function(){
-		// summary:
-		//		See dojo/data/api/Read.getFeatures()
-		return {
-			'dojo.data.api.Read': true,
-			'dojo.data.api.Write': true
-		};
-	},
-
-	newItem: function(/* Object? */ keywordArgs, /*Object?*/ parentInfo){
-		// summary:
-		//		Returns a newly created item.  Sets the attributes of the new
-		//		item based on the *keywordArgs* provided.  In general, the attribute
-		//		names in the keywords become the attributes in the new item and as for
-		//		the attribute values in keywordArgs, they become the values of the attributes
-		//		in the new item.  In addition, for stores that support hierarchical item
-		//		creation, an optional second parameter is accepted that defines what item is the parent
-		//		of the new item and what attribute of that item should the new item be assigned to.
-		//		In general, this will assume that the attribute targeted is multi-valued and a new item
-		//		is appended onto the list of values for that attribute.
-		// keywordArgs:
-		//		A javascript object defining the initial content of the item as a set of JavaScript 'property name: value' pairs.
-		// parentInfo:
-		//		An optional javascript object defining what item is the parent of this item (in a hierarchical store.  Not all stores do hierarchical items),
-		//		and what attribute of that parent to assign the new item to.  If this is present, and the attribute specified
-		//		is a multi-valued attribute, it will append this item into the array of values for that attribute.  The structure
-		//		of the object is as follows:
-		//	|	{
-		//	|		parent: someItem,
-		//	|		attribute: "attribute-name-string"
-		//	|	}
-		// exceptions:
-		//		Throws an exception if *keywordArgs* is a string or a number or
-		//		anything other than a simple anonymous object.
-		//		Throws an exception if the item in parentInfo is not an item from the store
-		//		or if the attribute isn't an attribute name string.
-		// example:
-		//	|	var kermit = store.newItem({name: "Kermit", color:[blue, green]});
-
-		throw new Error('Unimplemented API: dojo.data.api.Write.newItem');
-	},
-
-	deleteItem: function(/* dojo/data/api/Item */ item){
-		// summary:
-		//		Deletes an item from the store.
-		// item:
-		//		The item to delete.
-		// exceptions:
-		//		Throws an exception if the argument *item* is not an item
-		//		(if store.isItem(item) returns false).
-		// example:
-		//	|	var success = store.deleteItem(kermit);
-		throw new Error('Unimplemented API: dojo.data.api.Write.deleteItem');
-	},
-
-	setValue: function(	/* dojo/data/api/Item */ item,
-						/* string */ attribute,
-						/* almost anything */ value){
-		// summary:
-		//		Sets the value of an attribute on an item.
-		//		Replaces any previous value or values.
-		// item:
-		//		The item to modify.
-		// attribute:
-		//		The attribute of the item to change represented as a string name.
-		// value:
-		//		The value to assign to the item.
-		// exceptions:
-		//		Throws an exception if *item* is not an item, or if *attribute*
-		//		is neither an attribute object or a string.
-		//		Throws an exception if *value* is undefined.
-		// example:
-		//	|	var success = store.set(kermit, "color", "green");
-		throw new Error('Unimplemented API: dojo.data.api.Write.setValue');
-	},
-
-	setValues: function(/* dojo/data/api/Item */ item,
-						/* string */ attribute,
-						/* array */ values){
-		// summary:
-		//		Adds each value in the *values* array as a value of the given
-		//		attribute on the given item.
-		//		Replaces any previous value or values.
-		//		Calling store.setValues(x, y, []) (with *values* as an empty array) has
-		//		the same effect as calling store.unsetAttribute(x, y).
-		// item:
-		//		The item to modify.
-		// attribute:
-		//		The attribute of the item to change represented as a string name.
-		// values:
-		//		An array of values to assign to the attribute..
-		// exceptions:
-		//		Throws an exception if *values* is not an array, if *item* is not an
-		//		item, or if *attribute* is neither an attribute object or a string.
-		// example:
-		//	|	var success = store.setValues(kermit, "color", ["green", "aqua"]);
-		//	|	success = store.setValues(kermit, "color", []);
-		//	|	if (success){assert(!store.hasAttribute(kermit, "color"));}
-		throw new Error('Unimplemented API: dojo.data.api.Write.setValues');
-	},
-
-	unsetAttribute: function(	/* dojo/data/api/Item */ item,
-								/* string */ attribute){
-		// summary:
-		//		Deletes all the values of an attribute on an item.
-		// item:
-		//		The item to modify.
-		// attribute:
-		//		The attribute of the item to unset represented as a string.
-		// exceptions:
-		//		Throws an exception if *item* is not an item, or if *attribute*
-		//		is neither an attribute object or a string.
-		// example:
-		//	|	var success = store.unsetAttribute(kermit, "color");
-		//	|	if (success){assert(!store.hasAttribute(kermit, "color"));}
-		throw new Error('Unimplemented API: dojo.data.api.Write.clear');
-	},
-
-	save: function(/* object */ keywordArgs){
-		// summary:
-		//		Saves to the server all the changes that have been made locally.
-		//		The save operation may take some time and is generally performed
-		//		in an asynchronous fashion.  The outcome of the save action is
-		//		is passed into the set of supported callbacks for the save.
-		// keywordArgs:
-		// |	{
-		// |		onComplete: function
-		// |		onError: function
-		// |		scope: object
-		// |	}
-		//
-		//		####The *onComplete* parameter.
-		//
-		//		function();
-		//
-		//		If an onComplete callback function is provided, the callback function
-		//		will be called just once, after the save has completed.  No parameters
-		//		are generally passed to the onComplete.
-		//
-		//		####The *onError* parameter.
-		//
-		//		function(errorData);
-		//
-		//		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 save.  The onError function will be based one parameter, the
-		//		error.
-		//
-		//		####The *scope* parameter.
-		//
-		//		If a scope object is provided, all of the callback function (
-		//		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, onComplete.call(scope) vs.
-		//		onComplete.call(dojo.global)
-		// returns:
-		//		Nothing.  Since the saves are generally asynchronous, there is
-		//		no need to return anything.  All results are passed via callbacks.
-		// example:
-		//	|	store.save({onComplete: onSave});
-		//	|	store.save({scope: fooObj, onComplete: onSave, onError: saveFailed});
-		throw new Error('Unimplemented API: dojo.data.api.Write.save');
-	},
-
-	revert: function(){
-		// summary:
-		//		Discards any unsaved changes.
-		// description:
-		//		Discards any unsaved changes.
-		// example:
-		//	|	var success = store.revert();
-		throw new Error('Unimplemented API: dojo.data.api.Write.revert');
-	},
-
-	isDirty: function(/* item? */ item){
-		// summary:
-		//		Given an item, isDirty() returns true if the item has been modified
-		//		since the last save().  If isDirty() is called with no *item* argument,
-		//		then this function returns true if any item has been modified since
-		//		the last save().
-		// item:
-		//		The item to check.
-		// exceptions:
-		//		Throws an exception if isDirty() is passed an argument and the
-		//		argument is not an item.
-		// example:
-		//	|	var trueOrFalse = store.isDirty(kermit); // true if kermit is dirty
-		//	|	var trueOrFalse = store.isDirty();       // true if any item is dirty
-		throw new Error('Unimplemented API: dojo.data.api.Write.isDirty');
-	}
-});
-
-});

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

@@ -1,77 +0,0 @@
-define("dojo/data/util/filter", ["../../_base/lang"], function(lang){
-	// module:
-	//		dojo/data/util/filter
-	// summary:
-	//		TODOC
-
-var filter = {};
-lang.setObject("dojo.data.util.filter", filter);
-
-filter.patternToRegExp = function(/*String*/pattern, /*boolean?*/ ignoreCase){
-	// summary:
-	//		Helper function to convert a simple pattern to a regular expression for matching.
-	// description:
-	//		Returns a regular expression object that conforms to the defined conversion rules.
-	//		For example:
-	//
-	//		- ca*   -> /^ca.*$/
-	//		- *ca*  -> /^.*ca.*$/
-	//		- *c\*a*  -> /^.*c\*a.*$/
-	//		- *c\*a?*  -> /^.*c\*a..*$/
-	//
-	//		and so on.
-	// pattern: string
-	//		A simple matching pattern to convert that follows basic rules:
-	//
-	//		- * Means match anything, so ca* means match anything starting with ca
-	//		- ? Means match single character.  So, b?b will match to bob and bab, and so on.
-	//		- \ is an escape character.  So for example, \* means do not treat * as a match, but literal character *.
-	//
-	//		To use a \ as a character in the string, it must be escaped.  So in the pattern it should be
-	//		represented by \\ to be treated as an ordinary \ character instead of an escape.
-	// ignoreCase:
-	//		An optional flag to indicate if the pattern matching should be treated as case-sensitive or not when comparing
-	//		By default, it is assumed case sensitive.
-
-	var rxp = "^";
-	var c = null;
-	for(var i = 0; i < pattern.length; i++){
-		c = pattern.charAt(i);
-		switch(c){
-			case '\\':
-				rxp += c;
-				i++;
-				rxp += pattern.charAt(i);
-				break;
-			case '*':
-				rxp += ".*"; break;
-			case '?':
-				rxp += "."; break;
-			case '$':
-			case '^':
-			case '/':
-			case '+':
-			case '.':
-			case '|':
-			case '(':
-			case ')':
-			case '{':
-			case '}':
-			case '[':
-			case ']':
-				rxp += "\\"; //fallthrough
-			default:
-				rxp += c;
-		}
-	}
-	rxp += "$";
-	if(ignoreCase){
-		return new RegExp(rxp,"mi"); //RegExp
-	}else{
-		return new RegExp(rxp,"m"); //RegExp
-	}
-
-};
-
-return filter;
-});

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

@@ -1,240 +0,0 @@
-define("dojo/data/util/simpleFetch", ["../../_base/lang", "../../_base/kernel", "./sorter"],
-  function(lang, kernel, sorter){
-	// module:
-	//		dojo/data/util/simpleFetch
-	// 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.
-
-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 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:
-	//		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
-	//		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:
-	//		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;
-	}
-
-	this._fetchItems(request, lang.hitch(this, "fetchHandler"), lang.hitch(this, "errorHandler"));
-	return request;	// Object
-};
-
-return simpleFetch;
-});