dojo-rails 0.9.9 → 0.9.10

data/vendor/assets/javascripts/dojo/promise/Promise.js

@@ -0,0 +1,37 @@
+/*
+	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/promise/Promise",["../_base/lang"],function(_1){
+"use strict";
+function _2(){
+throw new TypeError("abstract");
+};
+return _1.extend(function Promise(){
+},{then:function(_3,_4,_5){
+_2();
+},cancel:function(_6,_7){
+_2();
+},isResolved:function(){
+_2();
+},isRejected:function(){
+_2();
+},isFulfilled:function(){
+_2();
+},isCanceled:function(){
+_2();
+},always:function(_8){
+return this.then(_8,_8);
+},otherwise:function(_9){
+return this.then(null,_9);
+},trace:function(){
+return this;
+},traceRejected:function(){
+return this;
+},toString:function(){
+return "[object Promise]";
+}});
+});

data/vendor/assets/javascripts/dojo/promise/Promise.js.uncompressed.js

@@ -0,0 +1,133 @@
+define("dojo/promise/Promise", [
+	"../_base/lang"
+], function(lang){
+	"use strict";
+
+	// module:
+	//		dojo/promise/Promise
+
+	function throwAbstract(){
+		throw new TypeError("abstract");
+	}
+
+	return lang.extend(function Promise(){
+		// summary:
+		//		The public interface to a deferred.
+		// description:
+		//		The public interface to a deferred. All promises in Dojo are
+		//		instances of this class.
+	}, {
+		then: function(callback, errback, progback){
+			// summary:
+			//		Add new callbacks to the promise.
+			// description:
+			//		Add new callbacks to the deferred. Callbacks can be added
+			//		before or after the deferred is fulfilled.
+			// callback: Function?
+			//		Callback to be invoked when the promise is resolved.
+			//		Receives the resolution value.
+			// errback: Function?
+			//		Callback to be invoked when the promise is rejected.
+			//		Receives the rejection error.
+			// progback: Function?
+			//		Callback to be invoked when the promise emits a progress
+			//		update. Receives the progress update.
+			// returns: dojo/promise/Promise
+			//		Returns a new promise for the result of the callback(s).
+			//		This can be used for chaining many asynchronous operations.
+
+			throwAbstract();
+		},
+
+		cancel: function(reason, strict){
+			// summary:
+			//		Inform the deferred it may cancel its asynchronous operation.
+			// description:
+			//		Inform the deferred it may cancel its asynchronous operation.
+			//		The deferred's (optional) canceler is invoked and the
+			//		deferred will be left in a rejected state. Can affect other
+			//		promises that originate with the same deferred.
+			// reason: any
+			//		A message that may be sent to the deferred's canceler,
+			//		explaining why it's being canceled.
+			// strict: Boolean?
+			//		If strict, will throw an error if the deferred has already
+			//		been fulfilled and consequently cannot be canceled.
+			// returns: any
+			//		Returns the rejection reason if the deferred was canceled
+			//		normally.
+
+			throwAbstract();
+		},
+
+		isResolved: function(){
+			// summary:
+			//		Checks whether the promise has been resolved.
+			// returns: Boolean
+
+			throwAbstract();
+		},
+
+		isRejected: function(){
+			// summary:
+			//		Checks whether the promise has been rejected.
+			// returns: Boolean
+
+			throwAbstract();
+		},
+
+		isFulfilled: function(){
+			// summary:
+			//		Checks whether the promise has been resolved or rejected.
+			// returns: Boolean
+
+			throwAbstract();
+		},
+
+		isCanceled: function(){
+			// summary:
+			//		Checks whether the promise has been canceled.
+			// returns: Boolean
+
+			throwAbstract();
+		},
+
+		always: function(callbackOrErrback){
+			// summary:
+			//		Add a callback to be invoked when the promise is resolved
+			//		or rejected.
+			// callbackOrErrback: Function?
+			//		A function that is used both as a callback and errback.
+			// returns: dojo/promise/Promise
+			//		Returns a new promise for the result of the callback/errback.
+
+			return this.then(callbackOrErrback, callbackOrErrback);
+		},
+
+		otherwise: function(errback){
+			// summary:
+			//		Add new errbacks to the promise.
+			// errback: Function?
+			//		Callback to be invoked when the promise is rejected.
+			// returns: dojo/promise/Promise
+			//		Returns a new promise for the result of the errback.
+
+			return this.then(null, errback);
+		},
+
+		trace: function(){
+			return this;
+		},
+
+		traceRejected: function(){
+			return this;
+		},
+
+		toString: function(){
+			// returns: string
+			//		Returns `[object Promise]`.
+
+			return "[object Promise]";
+		}
+	});
+});

data/vendor/assets/javascripts/dojo/promise/all.js

@@ -0,0 +1,60 @@
+/*
+	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/promise/all",["../_base/array","../Deferred","../when"],function(_1,_2,_3){
+"use strict";
+var _4=_1.some;
+return function all(_5){
+var _6,_1;
+if(_5 instanceof Array){
+_1=_5;
+}else{
+if(_5&&typeof _5==="object"){
+_6=_5;
+}
+}
+var _7;
+var _8=[];
+if(_6){
+_1=[];
+for(var _9 in _6){
+if(Object.hasOwnProperty.call(_6,_9)){
+_8.push(_9);
+_1.push(_6[_9]);
+}
+}
+_7={};
+}else{
+if(_1){
+_7=[];
+}
+}
+if(!_1||!_1.length){
+return new _2().resolve(_7);
+}
+var _a=new _2();
+_a.promise.always(function(){
+_7=_8=null;
+});
+var _b=_1.length;
+_4(_1,function(_c,_d){
+if(!_6){
+_8.push(_d);
+}
+_3(_c,function(_e){
+if(!_a.isFulfilled()){
+_7[_8[_d]]=_e;
+if(--_b===0){
+_a.resolve(_7);
+}
+}
+},_a.reject);
+return _a.isFulfilled();
+});
+return _a.promise;
+};
+});

data/vendor/assets/javascripts/dojo/promise/all.js.uncompressed.js

@@ -0,0 +1,76 @@
+define("dojo/promise/all", [
+	"../_base/array",
+	"../Deferred",
+	"../when"
+], function(array, Deferred, when){
+	"use strict";
+
+	// module:
+	//		dojo/promise/all
+
+	var some = array.some;
+
+	return function all(objectOrArray){
+		// summary:
+		//		Takes multiple promises and returns a new promise that is fulfilled
+		//		when all promises have been fulfilled.
+		// description:
+		//		Takes multiple promises and returns a new promise that is fulfilled
+		//		when all promises have been fulfilled. If one of the promises is rejected,
+		//		the returned promise is also rejected. Canceling the returned promise will
+		//		*not* cancel any passed promises.
+		// objectOrArray: Object|Array?
+		//		The promise will be fulfilled with a list of results if invoked with an
+		//		array, or an object of results when passed an object (using the same
+		//		keys). If passed neither an object or array it is resolved with an
+		//		undefined value.
+		// returns: dojo/promise/Promise
+
+		var object, array;
+		if(objectOrArray instanceof Array){
+			array = objectOrArray;
+		}else if(objectOrArray && typeof objectOrArray === "object"){
+			object = objectOrArray;
+		}
+
+		var results;
+		var keyLookup = [];
+		if(object){
+			array = [];
+			for(var key in object){
+				if(Object.hasOwnProperty.call(object, key)){
+					keyLookup.push(key);
+					array.push(object[key]);
+				}
+			}
+			results = {};
+		}else if(array){
+			results = [];
+		}
+
+		if(!array || !array.length){
+			return new Deferred().resolve(results);
+		}
+
+		var deferred = new Deferred();
+		deferred.promise.always(function(){
+			results = keyLookup = null;
+		});
+		var waiting = array.length;
+		some(array, function(valueOrPromise, index){
+			if(!object){
+				keyLookup.push(index);
+			}
+			when(valueOrPromise, function(value){
+				if(!deferred.isFulfilled()){
+					results[keyLookup[index]] = value;
+					if(--waiting === 0){
+						deferred.resolve(results);
+					}
+				}
+			}, deferred.reject);
+			return deferred.isFulfilled();
+		});
+		return deferred.promise;	// dojo/promise/Promise
+	};
+});

data/vendor/assets/javascripts/dojo/promise/first.js

@@ -0,0 +1,34 @@
+/*
+	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/promise/first",["../_base/array","../Deferred","../when"],function(_1,_2,_3){
+"use strict";
+var _4=_1.forEach;
+return function first(_5){
+var _6;
+if(_5 instanceof Array){
+_6=_5;
+}else{
+if(_5&&typeof _5==="object"){
+_6=[];
+for(var _7 in _5){
+if(Object.hasOwnProperty.call(_5,_7)){
+_6.push(_5[_7]);
+}
+}
+}
+}
+if(!_6||!_6.length){
+return new _2().resolve();
+}
+var _8=new _2();
+_4(_6,function(_9){
+_3(_9,_8.resolve,_8.reject);
+});
+return _8.promise;
+};
+});

data/vendor/assets/javascripts/dojo/promise/first.js.uncompressed.js

@@ -0,0 +1,49 @@
+define("dojo/promise/first", [
+	"../_base/array",
+	"../Deferred",
+	"../when"
+], function(array, Deferred, when){
+	"use strict";
+
+	// module:
+	//		dojo/promise/first
+
+	var forEach = array.forEach;
+
+	return function first(objectOrArray){
+		// summary:
+		//		Takes multiple promises and returns a new promise that is fulfilled
+		//		when the first of these promises is fulfilled.
+		// description:
+		//		Takes multiple promises and returns a new promise that is fulfilled
+		//		when the first of these promises is fulfilled. Canceling the returned
+		//		promise will *not* cancel any passed promises. The promise will be
+		//		fulfilled with the value of the first fulfilled promise.
+		// objectOrArray: Object|Array?
+		//		The promises are taken from the array or object values. If no value
+		//		is passed, the returned promise is resolved with an undefined value.
+		// returns: dojo/promise/Promise
+
+		var array;
+		if(objectOrArray instanceof Array){
+			array = objectOrArray;
+		}else if(objectOrArray && typeof objectOrArray === "object"){
+			array = [];
+			for(var key in objectOrArray){
+				if(Object.hasOwnProperty.call(objectOrArray, key)){
+					array.push(objectOrArray[key]);
+				}
+			}
+		}
+
+		if(!array || !array.length){
+			return new Deferred().resolve();
+		}
+
+		var deferred = new Deferred();
+		forEach(array, function(valueOrPromise){
+			when(valueOrPromise, deferred.resolve, deferred.reject);
+		});
+		return deferred.promise;	// dojo/promise/Promise
+	};
+});

data/vendor/assets/javascripts/dojo/promise/instrumentation.js

@@ -0,0 +1,86 @@
+/*
+	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/promise/instrumentation",["./tracer","../has","../_base/lang","../_base/array"],function(_1,_2,_3,_4){
+function _5(_6,_7,_8){
+var _9="";
+if(_6&&_6.stack){
+_9+=_6.stack;
+}
+if(_7&&_7.stack){
+_9+="\n    ----------------------------------------\n    rejected"+_7.stack.split("\n").slice(1).join("\n").replace(/^\s+/," ");
+}
+if(_8&&_8.stack){
+_9+="\n    ----------------------------------------\n"+_8.stack;
+}
+console.error(_6,_9);
+};
+function _a(_b,_c,_d,_e){
+if(!_c){
+_5(_b,_d,_e);
+}
+};
+var _f=[];
+var _10=false;
+var _11=1000;
+function _12(_13,_14,_15,_16){
+if(_14){
+_4.some(_f,function(obj,ix){
+if(obj.error===_13){
+_f.splice(ix,1);
+return true;
+}
+});
+}else{
+if(!_4.some(_f,function(obj){
+return obj.error===_13;
+})){
+_f.push({error:_13,rejection:_15,deferred:_16,timestamp:new Date().getTime()});
+}
+}
+if(!_10){
+_10=setTimeout(_17,_11);
+}
+};
+function _17(){
+var now=new Date().getTime();
+var _18=now-_11;
+_f=_4.filter(_f,function(obj){
+if(obj.timestamp<_18){
+_5(obj.error,obj.rejection,obj.deferred);
+return false;
+}
+return true;
+});
+if(_f.length){
+_10=setTimeout(_17,_f[0].timestamp+_11-now);
+}
+};
+return function(_19){
+var _1a=_2("config-useDeferredInstrumentation");
+if(_1a){
+_1.on("resolved",_3.hitch(console,"log","resolved"));
+_1.on("rejected",_3.hitch(console,"log","rejected"));
+_1.on("progress",_3.hitch(console,"log","progress"));
+var _1b=[];
+if(typeof _1a==="string"){
+_1b=_1a.split(",");
+_1a=_1b.shift();
+}
+if(_1a==="report-rejections"){
+_19.instrumentRejected=_a;
+}else{
+if(_1a==="report-unhandled-rejections"||_1a===true||_1a===1){
+_19.instrumentRejected=_12;
+_11=parseInt(_1b[0],10)||_11;
+}else{
+throw new Error("Unsupported instrumentation usage <"+_1a+">");
+}
+}
+}
+};
+});