dojo-rails 0.11.0 → 0.14.0

data/vendor/assets/javascripts/dojo/store/Observable.js.uncompressed.js

@@ -1,187 +0,0 @@
-define("dojo/store/Observable", ["../_base/kernel", "../_base/lang", "../_base/Deferred", "../_base/array" /*=====, "./api/Store" =====*/
-], function(kernel, lang, Deferred, array /*=====, Store =====*/){
-
-// module:
-//		dojo/store/Observable
-
-var Observable = function(/*Store*/ store){
-	// summary:
-	//		The Observable store wrapper takes a store and sets an observe method on query()
-	//		results that can be used to monitor results for changes.
-	//
-	// description:
-	//		Observable wraps an existing store so that notifications can be made when a query
-	//		is performed.
-	//
-	// example:
-	//		Create a Memory store that returns an observable query, and then log some
-	//		information about that query.
-	//
-	//	|	var store = Observable(new Memory({
-	//	|		data: [
-	//	|			{id: 1, name: "one", prime: false},
-	//	|			{id: 2, name: "two", even: true, prime: true},
-	//	|			{id: 3, name: "three", prime: true},
-	//	|			{id: 4, name: "four", even: true, prime: false},
-	//	|			{id: 5, name: "five", prime: true}
-	//	|		]
-	//	|	}));
-	//	|	var changes = [], results = store.query({ prime: true });
-	//	|	var observer = results.observe(function(object, previousIndex, newIndex){
-	//	|		changes.push({previousIndex:previousIndex, newIndex:newIndex, object:object});
-	//	|	});
-	//
-	//		See the Observable tests for more information.
-
-	var undef, queryUpdaters = [], revision = 0;
-	// a Comet driven store could directly call notify to notify observers when data has
-	// changed on the backend
-	// create a new instance
-	store = lang.delegate(store);
-	
-	store.notify = function(object, existingId){
-		revision++;
-		var updaters = queryUpdaters.slice();
-		for(var i = 0, l = updaters.length; i < l; i++){
-			updaters[i](object, existingId);
-		}
-	};
-	var originalQuery = store.query;
-	store.query = function(query, options){
-		options = options || {};
-		var results = originalQuery.apply(this, arguments);
-		if(results && results.forEach){
-			var nonPagedOptions = lang.mixin({}, options);
-			delete nonPagedOptions.start;
-			delete nonPagedOptions.count;
-
-			var queryExecutor = store.queryEngine && store.queryEngine(query, nonPagedOptions);
-			var queryRevision = revision;
-			var listeners = [], queryUpdater;
-			results.observe = function(listener, includeObjectUpdates){
-				if(listeners.push(listener) == 1){
-					// first listener was added, create the query checker and updater
-					queryUpdaters.push(queryUpdater = function(changed, existingId){
-						Deferred.when(results, function(resultsArray){
-							var atEnd = resultsArray.length != options.count;
-							var i, l, listener;
-							if(++queryRevision != revision){
-								throw new Error("Query is out of date, you must observe() the query prior to any data modifications");
-							}
-							var removedObject, removedFrom = -1, insertedInto = -1;
-							if(existingId !== undef){
-								// remove the old one
-								for(i = 0, l = resultsArray.length; i < l; i++){
-									var object = resultsArray[i];
-									if(store.getIdentity(object) == existingId){
-										removedObject = object;
-										removedFrom = i;
-										if(queryExecutor || !changed){// if it was changed and we don't have a queryExecutor, we shouldn't remove it because updated objects would be eliminated
-											resultsArray.splice(i, 1);
-										}
-										break;
-									}
-								}
-							}
-							if(queryExecutor){
-								// add the new one
-								if(changed &&
-										// if a matches function exists, use that (probably more efficient)
-										(queryExecutor.matches ? queryExecutor.matches(changed) : queryExecutor([changed]).length)){
-
-									var firstInsertedInto = removedFrom > -1 ? 
-										removedFrom : // put back in the original slot so it doesn't move unless it needs to (relying on a stable sort below)
-										resultsArray.length;
-									resultsArray.splice(firstInsertedInto, 0, changed); // add the new item
-									insertedInto = array.indexOf(queryExecutor(resultsArray), changed); // sort it
-									// we now need to push the chagne back into the original results array
-									resultsArray.splice(firstInsertedInto, 1); // remove the inserted item from the previous index
-									
-									if((options.start && insertedInto == 0) ||
-										(!atEnd && insertedInto == resultsArray.length)){
-										// if it is at the end of the page, assume it goes into the prev or next page
-										insertedInto = -1;
-									}else{
-										resultsArray.splice(insertedInto, 0, changed); // and insert into the results array with the correct index
-									}
-								}
-							}else if(changed){
-								// we don't have a queryEngine, so we can't provide any information
-								// about where it was inserted or moved to. If it is an update, we leave it's position alone, other we at least indicate a new object
-								if(existingId !== undef){
-									// an update, keep the index the same
-									insertedInto = removedFrom;
-								}else if(!options.start){
-									// a new object
-									insertedInto = store.defaultIndex || 0;
-									resultsArray.splice(insertedInto, 0, changed);
-								}
-							}
-							if((removedFrom > -1 || insertedInto > -1) &&
-									(includeObjectUpdates || !queryExecutor || (removedFrom != insertedInto))){
-								var copyListeners = listeners.slice();
-								for(i = 0;listener = copyListeners[i]; i++){
-									listener(changed || removedObject, removedFrom, insertedInto);
-								}
-							}
-						});
-					});
-				}
-				var handle = {};
-				// TODO: Remove cancel in 2.0.
-				handle.remove = handle.cancel = function(){
-					// remove this listener
-					var index = array.indexOf(listeners, listener);
-					if(index > -1){ // check to make sure we haven't already called cancel
-						listeners.splice(index, 1);
-						if(!listeners.length){
-							// no more listeners, remove the query updater too
-							queryUpdaters.splice(array.indexOf(queryUpdaters, queryUpdater), 1);
-						}
-					}
-				};
-				return handle;
-			};
-		}
-		return results;
-	};
-	var inMethod;
-	function whenFinished(method, action){
-		var original = store[method];
-		if(original){
-			store[method] = function(value){
-				if(inMethod){
-					// if one method calls another (like add() calling put()) we don't want two events
-					return original.apply(this, arguments);
-				}
-				inMethod = true;
-				try{
-					var results = original.apply(this, arguments);
-					Deferred.when(results, function(results){
-						action((typeof results == "object" && results) || value);
-					});
-					return results;
-				}finally{
-					inMethod = false;
-				}
-			};
-		}
-	}
-	// monitor for updates by listening to these methods
-	whenFinished("put", function(object){
-		store.notify(object, store.getIdentity(object));
-	});
-	whenFinished("add", function(object){
-		store.notify(object);
-	});
-	whenFinished("remove", function(id){
-		store.notify(undefined, id);
-	});
-
-	return store;
-};
-
-lang.setObject("dojo.store.util.Observable", Observable);
-
-return Observable;
-});

data/vendor/assets/javascripts/dojo/store/api/Store.js.uncompressed.js

@@ -1,287 +0,0 @@
-define("dojo/store/api/Store", ["../../_base/declare"], function(declare){
-
-// module:
-//		dojo/api/Store
-
-var Store = declare(null, {
-	// summary:
-	//		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 information on the ,
-	//		please visit: http://dojotoolkit.org/reference-guide/dojo/store.html
-	//		Every method and property is optional, and is only needed if the functionality
-	//		it provides is required.
-	//		Every method may return a promise for the specified return value if the
-	//		execution of the operation is asynchronous (except
-	//		for query() which already defines an async return value).
-
-	// idProperty: String
-	//		If the store has a single primary key, this indicates the property to use as the
-	//		identity property. The values of this property should be unique.
-	idProperty: "id",
-
-	// queryEngine: Function
-	//		If the store can be queried locally (on the client side in JS), this defines
-	//		the query engine to use for querying the data store.
-	//		This takes a query and query options and returns a function that can execute
-	//		the provided query on a JavaScript array. The queryEngine may be replace to
-	//		provide more sophisticated querying capabilities. For example:
-	//		| var query = store.queryEngine({foo:"bar"}, {count:10});
-	//		| query(someArray) -> filtered array
-	//		The returned query function may have a "matches" property that can be
-	//		used to determine if an object matches the query. For example:
-	//		| query.matches({id:"some-object", foo:"bar"}) -> true
-	//		| query.matches({id:"some-object", foo:"something else"}) -> false
-	queryEngine: null,
-
-	get: function(id){
-		// summary:
-		//		Retrieves an object by its identity
-		// id: Number
-		//		The identity to use to lookup the object
-		// returns: Object
-		//		The object in the store that matches the given id.
-	},
-	getIdentity: function(object){
-		// summary:
-		//		Returns an object's identity
-		// object: Object
-		//		The object to get the identity from
-		// returns: String|Number
-	},
-	put: function(object, directives){
-		// summary:
-		//		Stores an object
-		// object: Object
-		//		The object to store.
-		// directives: Store.PutDirectives?
-		//		Additional directives for storing objects.
-		// returns: Number|String
-	},
-	add: function(object, directives){
-		// summary:
-		//		Creates an object, throws an error if the object already exists
-		// object: Object
-		//		The object to store.
-		// directives: Store.PutDirectives?
-		//		Additional directives for creating objects.
-		// returns: Number|String
-	},
-	remove: function(id){
-		// summary:
-		//		Deletes an object by its identity
-		// id: Number
-		//		The identity to use to delete the object
-		delete this.index[id];
-		var data = this.data,
-			idProperty = this.idProperty;
-		for(var i = 0, l = data.length; i < l; i++){
-			if(data[i][idProperty] == id){
-				data.splice(i, 1);
-				return;
-			}
-		}
-	},
-	query: function(query, options){
-		// summary:
-		//		Queries the store for objects. This does not alter the store, but returns a
-		//		set of data from the store.
-		// query: String|Object|Function
-		//		The query to use for retrieving objects from the store.
-		// options: Store.QueryOptions
-		//		The optional arguments to apply to the resultset.
-		// returns: Store.QueryResults
-		//		The results of the query, extended with iterative methods.
-		//
-		// example:
-		//		Given the following store:
-		//
-		//	...find all items where "prime" is true:
-		//
-		//	|	store.query({ prime: true }).forEach(function(object){
-		//	|		// handle each object
-		//	|	});
-	},
-	transaction: function(){
-		// summary:
-		//		Starts a new transaction.
-		//		Note that a store user might not call transaction() prior to using put,
-		//		delete, etc. in which case these operations effectively could be thought of
-		//		as "auto-commit" style actions.
-		// returns: Store.Transaction
-		//		This represents the new current transaction.
-	},
-	getChildren: function(parent, options){
-		// summary:
-		//		Retrieves the children of an object.
-		// parent: Object
-		//		The object to find the children of.
-		// options: Store.QueryOptions?
-		//		Additional options to apply to the retrieval of the children.
-		// returns: Store.QueryResults
-		//		A result set of the children of the parent object.
-	},
-	getMetadata: function(object){
-		// summary:
-		//		Returns any metadata about the object. This may include attribution,
-		//		cache directives, history, or version information.
-		// object: Object
-		//		The object to return metadata for.
-		// returns: Object
-		//		An object containing metadata.
-	}
-});
-
-Store.PutDirectives = declare(null, {
-	// summary:
-	//		Directives passed to put() and add() handlers for guiding the update and
-	//		creation of stored objects.
-	// id: String|Number?
-	//		Indicates the identity of the object if a new object is created
-	// before: Object?
-	//		If the collection of objects in the store has a natural ordering,
-	//		this indicates that the created or updated object should be placed before the
-	//		object specified by the value of this property. A value of null indicates that the
-	//		object should be last.
-	// parent: Object?,
-	//		If the store is hierarchical (with single parenting) this property indicates the
-	//		new parent of the created or updated object.
-	// overwrite: Boolean?
-	//		If this is provided as a boolean it indicates that the object should or should not
-	//		overwrite an existing object. A value of true indicates that a new object
-	//		should not be created, the operation should update an existing object. A
-	//		value of false indicates that an existing object should not be updated, a new
-	//		object should be created (which is the same as an add() operation). When
-	//		this property is not provided, either an update or creation is acceptable.
-});
-
-Store.SortInformation = declare(null, {
-	// summary:
-	//		An object describing what attribute to sort on, and the direction of the sort.
-	// attribute: String
-	//		The name of the attribute to sort on.
-	// descending: Boolean
-	//		The direction of the sort.  Default is false.
-});
-
-Store.QueryOptions = declare(null, {
-	// summary:
-	//		Optional object with additional parameters for query results.
-	// sort: Store.SortInformation[]?
-	//		A list of attributes to sort on, as well as direction
-	//		For example:
-	//		| [{attribute:"price, descending: true}].
-	//		If the sort parameter is omitted, then the natural order of the store may be
-	//		applied if there is a natural order.
-	// start: Number?
-	//		The first result to begin iteration on
-	// count: Number?
-	//		The number of how many results should be returned.
-});
-
-Store.QueryResults = declare(null, {
-	// summary:
-	//		This is an object returned from query() calls that provides access to the results
-	//		of a query. Queries may be executed asynchronously.
-
-	forEach: function(callback, thisObject){
-		// summary:
-		//		Iterates over the query results, based on
-		//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach.
-		//		Note that this may executed asynchronously. The callback may be called
-		//		after this function returns.
-		// callback:
-		//		Function that is called for each object in the query results
-		// thisObject:
-		//		The object to use as |this| in the callback.
-
-	},
-	filter: function(callback, thisObject){
-		// summary:
-		//		Filters the query results, based on
-		//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter.
-		//		Note that this may executed asynchronously. The callback may be called
-		//		after this function returns.
-		// callback:
-		//		Function that is called for each object in the query results
-		// thisObject:
-		//		The object to use as |this| in the callback.
-		// returns: Store.QueryResults
-	},
-	map: function(callback, thisObject){
-		// summary:
-		//		Maps the query results, based on
-		//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map.
-		//		Note that this may executed asynchronously. The callback may be called
-		//		after this function returns.
-		// callback:
-		//		Function that is called for each object in the query results
-		// thisObject:
-		//		The object to use as |this| in the callback.
-		// returns: Store.QueryResults
-	},
-	then: function(callback, errorHandler){
-		// summary:
-		//		This registers a callback for when the query is complete, if the query is asynchronous.
-		//		This is an optional method, and may not be present for synchronous queries.
-		// callback:
-		//		This is called when the query is completed successfully, and is passed a single argument
-		//		that is an array representing the query results.
-		// errorHandler:
-		//		This is called if the query failed, and is passed a single argument that is the error
-		//		for the failure.
-	},
-	observe: function(listener, includeAllUpdates){
-		// summary:
-		//		This registers a callback for notification of when data is modified in the query results.
-		//		This is an optional method, and is usually provided by dojo/store/Observable.
-		// listener: Function
-		//		The listener function is called when objects in the query results are modified
-		//		to affect the query result. The listener function is called with the following arguments:
-		//		| listener(object, removedFrom, insertedInto);
-		//
-		//		- The object parameter indicates the object that was create, modified, or deleted.
-		//		- The removedFrom parameter indicates the index in the result array where
-		//		the object used to be. If the value is -1, then the object is an addition to
-		//		this result set (due to a new object being created, or changed such that it
-		//		is a part of the result set).
-		//		- The insertedInto parameter indicates the index in the result array where
-		//		the object should be now. If the value is -1, then the object is a removal
-		//		from this result set (due to an object being deleted, or changed such that it
-		//		is not a part of the result set).
-		// includeAllUpdates:
-		//		This indicates whether or not to include object updates that do not affect
-		//		the inclusion or order of the object in the query results. By default this is false,
-		//		which means that if any object is updated in such a way that it remains
-		//		in the result set and it's position in result sets is not affected, then the listener
-		//		will not be fired.
-
-	},
-	// total: Number|Promise?
-	//		This property should be included in if the query options included the "count"
-	//		property limiting the result set. This property indicates the total number of objects
-	//		matching the query (as if "start" and "count" weren't present). This may be
-	//		a promise if the query is asynchronous.
-	total: 0
-});
-
-Store.Transaction = declare(null, {
-	// summary:
-	//		This is an object returned from transaction() calls that represents the current
-	//		transaction.
-
-	commit: function(){
-		// summary:
-		//		Commits the transaction. This may throw an error if it fails. Of if the operation
-		//		is asynchronous, it may return a promise that represents the eventual success
-		//		or failure of the commit.
-	},
-	abort: function(callback, thisObject){
-		// summary:
-		//		Aborts the transaction. This may throw an error if it fails. Of if the operation
-		//		is asynchronous, it may return a promise that represents the eventual success
-		//		or failure of the abort.
-	}
-});
-return Store;
-});