dojo-rails 0.9.8 → 0.9.9

data/vendor/assets/javascripts/dojo/store/Cache.js

@@ -0,0 +1,47 @@
+/*
+	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/Cache",["../_base/lang","../_base/Deferred"],function(_1,_2){
+var _3=_1.getObject("dojo.store",true);
+_3.Cache=function(_4,_5,_6){
+_6=_6||{};
+return _1.delegate(_4,{query:function(_7,_8){
+var _9=_4.query(_7,_8);
+_9.forEach(function(_a){
+if(!_6.isLoaded||_6.isLoaded(_a)){
+_5.put(_a);
+}
+});
+return _9;
+},queryEngine:_4.queryEngine||_5.queryEngine,get:function(id,_b){
+return _2.when(_5.get(id),function(_c){
+return _c||_2.when(_4.get(id,_b),function(_d){
+if(_d){
+_5.put(_d,{id:id});
+}
+return _d;
+});
+});
+},add:function(_e,_f){
+return _2.when(_4.add(_e,_f),function(_10){
+return _5.add(typeof _10=="object"?_10:_e,_f);
+});
+},put:function(_11,_12){
+_5.remove((_12&&_12.id)||this.getIdentity(_11));
+return _2.when(_4.put(_11,_12),function(_13){
+return _5.put(typeof _13=="object"?_13:_11,_12);
+});
+},remove:function(id,_14){
+return _2.when(_4.remove(id,_14),function(_15){
+return _5.remove(id,_14);
+});
+},evict:function(id){
+return _5.remove(id);
+}});
+};
+return _3.Cache;
+});

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

@@ -0,0 +1,148 @@
+define("dojo/store/Cache", ["../_base/lang","../_base/Deferred"
+],function(lang, Deferred) {
+	// module:
+	//		dojo/store/Cache
+	// summary:
+	//		TODOC
+
+var store = lang.getObject("dojo.store", true);
+
+/*=====
+dojo.declare("dojo.store.__CacheArgs", null, {
+	constructor: function(){
+		// summary:
+		//		These are additional options for how caching is handled.
+		// isLoaded: Function?
+		//		This is a function that will be called for each item in a query response to determine
+		//		if it is cacheable. If isLoaded returns true, the item will be cached, otherwise it
+		//		will not be cached. If isLoaded is not provided, all items will be cached.
+		this.isLoaded = isLoaded;
+	}
+});
+=====*/
+store.Cache = function(masterStore, cachingStore, /*dojo.store.__CacheArgs*/ options){
+	// summary:
+	//		The Cache store wrapper takes a master store and a caching store,
+	//		caches data from the master into the caching store for faster
+	//		lookup. Normally one would use a memory store for the caching
+	//		store and a server store like JsonRest for the master store.
+	// masterStore:
+	//		This is the authoritative store, all uncached requests or non-safe requests will
+	//		be made against this store.
+	// cachingStore:
+	//		This is the caching store that will be used to store responses for quick access.
+	//		Typically this should be a local store.
+	// options:
+	//		These are additional options for how caching is handled.
+	options = options || {};
+	return lang.delegate(masterStore, {
+		query: function(query, directives){
+			var results = masterStore.query(query, directives);
+			results.forEach(function(object){
+				if(!options.isLoaded || options.isLoaded(object)){
+					cachingStore.put(object);
+				}
+			});
+			return results;
+		},
+		// look for a queryEngine in either store
+		queryEngine: masterStore.queryEngine || cachingStore.queryEngine,
+		get: function(id, directives){
+			return Deferred.when(cachingStore.get(id), function(result){
+				return result || Deferred.when(masterStore.get(id, directives), function(result){
+					if(result){
+						cachingStore.put(result, {id: id});
+					}
+					return result;
+				});
+			});
+		},
+		add: function(object, directives){
+			return Deferred.when(masterStore.add(object, directives), function(result){
+				// now put result in cache
+				return cachingStore.add(typeof result == "object" ? result : object, directives);
+			});
+		},
+		put: function(object, directives){
+			// first remove from the cache, so it is empty until we get a response from the master store
+			cachingStore.remove((directives && directives.id) || this.getIdentity(object));
+			return Deferred.when(masterStore.put(object, directives), function(result){
+				// now put result in cache
+				return cachingStore.put(typeof result == "object" ? result : object, directives);
+			});
+		},
+		remove: function(id, directives){
+			return Deferred.when(masterStore.remove(id, directives), function(result){
+				return cachingStore.remove(id, directives);
+			});
+		},
+		evict: function(id){
+			return cachingStore.remove(id);
+		}
+	});
+};
+/*=====
+dojo.declare("dojo.store.Cache", null, {
+	// example:
+	//	|	var master = new dojo.store.Memory(data);
+	//	|	var cacher = new dojo.store.Memory();
+	//	|	var store = new dojo.store.Cache(master, cacher);
+	//
+	query: function(query, directives){
+		// summary:
+		//		Query the underlying master store and cache any results.
+		// query: Object|String
+		//		The object or string containing query information. Dependent on the query engine used.
+		// directives: dojo.store.util.SimpleQueryEngine.__queryOptions?
+		//		An optional keyword arguments object with additional parameters describing the query.
+		// returns: dojo.store.util.QueryResults
+		//		A QueryResults object that can be used to iterate over.
+	},
+	get: function(id, directives){
+		// summary:
+		//		Get the object with the specific id.
+		// id: Number
+		//		The identifier for the object in question.
+		// directives: dojo.store.__GetOptions?
+		//		Any additional parameters needed to describe how the get should be performed.
+		// returns: dojo.store.util.QueryResults
+		//		A QueryResults object.
+	},
+	add: function(object, directives){
+		// summary:
+		//		Add the given object to the store.
+		// object: Object
+		//		The object to add to the store.
+		// directives: dojo.store.__AddOptions?
+		//		Any additional parameters needed to describe how the add should be performed.
+		// returns: Number
+		//		The new id for the object.
+	},
+	put: function(object, directives){
+		// summary:
+		//		Put the object into the store (similar to an HTTP PUT).
+		// object: Object
+		//		The object to put to the store.
+		// directives: dojo.store.__PutOptions?
+		//		Any additional parameters needed to describe how the put should be performed.
+		// returns: Number
+		//		The new id for the object.
+	},
+	remove: function(id, directives){
+		// summary:
+		//		Remove the object with the specific id.
+		// id: Number
+		//		The identifier for the object in question.
+		// directives: dojo.store.__RemoveOptions?
+		//		Any additional parameters needed to describe how the remove should be performed.
+	},
+	evict: function(id){
+		// summary:
+		//		Remove the object with the given id from the underlying caching store.
+		// id: Number
+		//		The identifier for the object in question.
+	}
+});
+=====*/
+return store.Cache;
+});

data/vendor/assets/javascripts/dojo/store/DataStore.js

@@ -0,0 +1,103 @@
+/*
+	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/DataStore",["../_base/lang","../_base/declare","../_base/Deferred","../_base/array","./util/QueryResults"],function(_1,_2,_3,_4,_5){
+return _2("dojo.store.DataStore",null,{target:"",constructor:function(_6){
+_1.mixin(this,_6);
+if(!"idProperty" in _6){
+var _7;
+try{
+_7=this.store.getIdentityAttributes();
+}
+catch(e){
+}
+this.idProperty=(!_7||!idAttributes[0])||this.idProperty;
+}
+var _8=this.store.getFeatures();
+if(!_8["dojo.data.api.Read"]){
+this.get=null;
+}
+if(!_8["dojo.data.api.Identity"]){
+this.getIdentity=null;
+}
+if(!_8["dojo.data.api.Write"]){
+this.put=this.add=null;
+}
+},idProperty:"id",store:null,_objectConverter:function(_9){
+var _a=this.store;
+var _b=this.idProperty;
+return function(_c){
+var _d={};
+var _e=_a.getAttributes(_c);
+for(var i=0;i<_e.length;i++){
+_d[_e[i]]=_a.getValue(_c,_e[i]);
+}
+if(!(_b in _d)){
+_d[_b]=_a.getIdentity(_c);
+}
+return _9(_d);
+};
+},get:function(id,_f){
+var _10,_11;
+var _12=new _3();
+this.store.fetchItemByIdentity({identity:id,onItem:this._objectConverter(function(_13){
+_12.resolve(_10=_13);
+}),onError:function(_14){
+_12.reject(_11=_14);
+}});
+if(_10){
+return _10;
+}
+if(_11){
+throw _11;
+}
+return _12.promise;
+},put:function(_15,_16){
+var id=_16&&typeof _16.id!="undefined"||this.getIdentity(_15);
+var _17=this.store;
+var _18=this.idProperty;
+if(typeof id=="undefined"){
+_17.newItem(_15);
+}else{
+_17.fetchItemByIdentity({identity:id,onItem:function(_19){
+if(_19){
+for(var i in _15){
+if(i!=_18&&_17.getValue(_19,i)!=_15[i]){
+_17.setValue(_19,i,_15[i]);
+}
+}
+}else{
+_17.newItem(_15);
+}
+}});
+}
+},remove:function(id){
+var _1a=this.store;
+this.store.fetchItemByIdentity({identity:id,onItem:function(_1b){
+_1a.deleteItem(_1b);
+}});
+},query:function(_1c,_1d){
+var _1e;
+var _1f=new _3(function(){
+_1e.abort&&_1e.abort();
+});
+_1f.total=new _3();
+var _20=this._objectConverter(function(_21){
+return _21;
+});
+_1e=this.store.fetch(_1.mixin({query:_1c,onBegin:function(_22){
+_1f.total.resolve(_22);
+},onComplete:function(_23){
+_1f.resolve(_4.map(_23,_20));
+},onError:function(_24){
+_1f.reject(_24);
+}},_1d));
+return _5(_1f);
+},getIdentity:function(_25){
+return _25[this.idProperty];
+}});
+});

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

@@ -0,0 +1,170 @@
+define("dojo/store/DataStore", ["../_base/lang", "../_base/declare", "../_base/Deferred", "../_base/array", "./util/QueryResults"
+], function(lang,declare,Deferred,array,QueryResults) {
+	// module:
+	//		dojo/store/DataStore
+	// summary:
+	//		TODOC
+
+
+return declare("dojo.store.DataStore", null, {
+	target: "",
+	constructor: function(options){
+		// summary:
+		//		This is an adapter for using Dojo Data stores with an object store consumer.
+		//		You can provide a Dojo data store and use this adapter to interact with it through
+		//		the Dojo object store API
+		// options: Object?
+		//		This provides any configuration information that will be mixed into the store,
+		//		including a reference to the Dojo data store under the property "store".
+		lang.mixin(this, options);
+ 		if(!"idProperty" in options){
+			var idAttribute; 
+			try{
+				idAttribute = this.store.getIdentityAttributes(); 
+			}catch(e){ 
+	 		// some store are not requiring an item instance to give us the ID attributes 
+	 		// but some other do and throw errors in that case. 
+			} 
+			// if no idAttribute we have implicit id 
+			this.idProperty = (!idAttribute || !idAttributes[0]) || this.idProperty; 
+		}
+		var features = this.store.getFeatures();
+		// check the feature set and null out any methods that shouldn't be available
+		if(!features["dojo.data.api.Read"]){
+			this.get = null;
+		}
+		if(!features["dojo.data.api.Identity"]){
+			this.getIdentity = null;
+		}
+		if(!features["dojo.data.api.Write"]){
+			this.put = this.add = null;
+		}
+	},
+	// idProperty: String
+	//		The object property to use to store the identity of the store items.
+	idProperty: "id",
+	// store:
+	//		The object store to convert to a data store
+	store: null,
+	_objectConverter: function(callback){
+		var store = this.store;
+		var idProperty = this.idProperty;
+		return function(item){
+			var object = {};
+			var attributes = store.getAttributes(item);
+			for(var i = 0; i < attributes.length; i++){
+				object[attributes[i]] = store.getValue(item, attributes[i]);
+			}
+			if(!(idProperty in object)){
+				object[idProperty] = store.getIdentity(item);
+			}
+			return callback(object);
+		};
+	},
+	get: function(id, options){
+		// summary:
+		//		Retrieves an object by it's identity. This will trigger a fetchItemByIdentity
+		// id: Object?
+		//		The identity to use to lookup the object
+		var returnedObject, returnedError;
+		var deferred = new Deferred();
+		this.store.fetchItemByIdentity({
+			identity: id,
+			onItem: this._objectConverter(function(object){
+				deferred.resolve(returnedObject = object);
+			}),
+			onError: function(error){
+				deferred.reject(returnedError = error);
+			}
+		});
+		if(returnedObject){
+			// if it was returned synchronously
+			return returnedObject;
+		}
+		if(returnedError){
+			throw returnedError;
+		}
+		return deferred.promise;
+	},
+	put: function(object, options){
+		// summary:
+		//		Stores an object by its identity.
+		// object: Object
+		//		The object to store.
+		// options: Object?
+		//		Additional metadata for storing the data.  Includes a reference to an id
+		//		that the object may be stored with (i.e. { id: "foo" }).
+		var id = options && typeof options.id != "undefined" || this.getIdentity(object);
+		var store = this.store;
+		var idProperty = this.idProperty;
+		if(typeof id == "undefined"){
+			store.newItem(object);
+		}else{
+			store.fetchItemByIdentity({
+				identity: id,
+				onItem: function(item){
+					if(item){
+						for(var i in object){
+							if(i != idProperty && // don't copy id properties since they are immutable and should be omitted for implicit ids 
+									store.getValue(item, i) != object[i]){
+								store.setValue(item, i, object[i]);
+							}
+						}
+					}else{
+						store.newItem(object);
+					}
+				}
+			});
+		}
+	},
+	remove: function(id){
+		// summary:
+		//		Deletes an object by its identity.
+		// id: Object
+		//		The identity to use to delete the object
+		var store = this.store;
+		this.store.fetchItemByIdentity({
+			identity: id,
+			onItem: function(item){
+				store.deleteItem(item);
+			}
+		});
+	},
+	query: function(query, options){
+		// summary:
+		//		Queries the store for objects.
+		// query: Object
+		//		The query to use for retrieving objects from the store
+		// options: Object?
+		//		Optional options object as used by the underlying dojo.data Store.
+		// returns: dojo.store.util.QueryResults
+		//		A query results object that can be used to iterate over results.
+		var fetchHandle;
+		var deferred = new Deferred(function(){ fetchHandle.abort && fetchHandle.abort(); });
+		deferred.total = new Deferred();
+		var converter = this._objectConverter(function(object){return object;});
+		fetchHandle = this.store.fetch(lang.mixin({
+			query: query,
+			onBegin: function(count){
+				deferred.total.resolve(count);
+			},
+			onComplete: function(results){
+				deferred.resolve(array.map(results, converter));
+			},
+			onError: function(error){
+				deferred.reject(error);
+			}
+		}, options));
+		return QueryResults(deferred);
+	},
+	getIdentity: function(object){
+		// summary:
+		//		Fetch the identity for the given object.
+		// object: Object
+		//		The data object to get the identity from.
+		// returns: Number
+		//		The id of the given object.
+		return object[this.idProperty];
+	}
+});
+});