dojo-rails 0.9.9 → 0.9.10

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

@@ -0,0 +1,145 @@
+define("dojo/request/util", [
+	'exports',
+	'../errors/RequestError',
+	'../errors/CancelError',
+	'../Deferred',
+	'../io-query',
+	'../_base/array',
+	'../_base/lang'
+], function(exports, RequestError, CancelError, Deferred, ioQuery, array, lang){
+	exports.deepCopy = function deepCopy(target, source){
+		for(var name in source){
+			var tval = target[name],
+				sval = source[name];
+			if(tval !== sval){
+				if(tval && typeof tval === 'object' && sval && typeof sval === 'object'){
+					exports.deepCopy(tval, sval);
+				}else{
+					target[name] = sval;
+				}
+			}
+		}
+		return target;
+	};
+
+	exports.deepCreate = function deepCreate(source, properties){
+		properties = properties || {};
+		var target = lang.delegate(source),
+			name, value;
+
+		for(name in source){
+			value = source[name];
+
+			if(value && typeof value === 'object'){
+				target[name] = exports.deepCreate(value, properties[name]);
+			}
+		}
+		return exports.deepCopy(target, properties);
+	};
+
+	var freeze = Object.freeze || function(obj){ return obj; };
+	function okHandler(response){
+		return freeze(response);
+	}
+
+	exports.deferred = function deferred(response, cancel, isValid, isReady, handleResponse, last){
+		var def = new Deferred(function(reason){
+			cancel && cancel(def, response);
+
+			if(!reason || !(reason instanceof RequestError) && !(reason instanceof CancelError)){
+				return new CancelError('Request canceled', response);
+			}
+			return reason;
+		});
+
+		def.response = response;
+		def.isValid = isValid;
+		def.isReady = isReady;
+		def.handleResponse = handleResponse;
+
+		function errHandler(error){
+			error.response = response;
+			throw error;
+		}
+		var responsePromise = def.then(okHandler).otherwise(errHandler);
+
+		if(exports.notify){
+			responsePromise.then(
+				lang.hitch(exports.notify, 'emit', 'load'),
+				lang.hitch(exports.notify, 'emit', 'error')
+			);
+		}
+
+		var dataPromise = responsePromise.then(function(response){
+				return response.data || response.text;
+			});
+
+		var promise = freeze(lang.delegate(dataPromise, {
+			response: responsePromise
+		}));
+
+
+		if(last){
+			def.then(function(response){
+				last.call(def, response);
+			}, function(error){
+				last.call(def, response, error);
+			});
+		}
+
+		def.promise = promise;
+		def.then = promise.then;
+
+		return def;
+	};
+
+	exports.addCommonMethods = function addCommonMethods(provider, methods){
+		array.forEach(methods||['GET', 'POST', 'PUT', 'DELETE'], function(method){
+			provider[(method === 'DELETE' ? 'DEL' : method).toLowerCase()] = function(url, options){
+				options = lang.delegate(options||{});
+				options.method = method;
+				return provider(url, options);
+			};
+		});
+	};
+
+	exports.parseArgs = function parseArgs(url, options, skipData){
+		var data = options.data,
+			query = options.query;
+		
+		if(data && !skipData){
+			if(typeof data === 'object'){
+				options.data = ioQuery.objectToQuery(data);
+			}
+		}
+
+		if(query){
+			if(typeof query === 'object'){
+				query = ioQuery.objectToQuery(query);
+			}
+			if(options.preventCache){
+				query += (query ? '&' : '') + 'request.preventCache=' + (+(new Date));
+			}
+		}else if(options.preventCache){
+			query = 'request.preventCache=' + (+(new Date));
+		}
+
+		if(url && query){
+			url += (~url.indexOf('?') ? '&' : '?') + query;
+		}
+
+		return {
+			url: url,
+			options: options,
+			getHeader: function(headerName){ return null; }
+		};
+	};
+
+	exports.checkStatus = function(stat){
+		stat = stat || 0;
+		return (stat >= 200 && stat < 300) || // allow any 2XX response code
+			stat === 304 ||                 // or, get it out of the cache
+			stat === 1223 ||                // or, Internet Explorer mangled the status code
+			!stat;                         // or, we're Titanium/browser chrome/chrome extension requesting a local file
+	};
+});

data/vendor/assets/javascripts/dojo/request/watch.js

@@ -0,0 +1,73 @@
+/*
+	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/request/watch",["./util","../errors/RequestTimeoutError","../errors/CancelError","../_base/array","../_base/window","../has!host-browser?dom-addeventlistener?:../on:"],function(_1,_2,_3,_4,_5,on){
+var _6=null,_7=[];
+function _8(){
+var _9=+(new Date);
+for(var i=0,_a;i<_7.length&&(_a=_7[i]);i++){
+var _b=_a.response,_c=_b.options;
+if((_a.isCanceled&&_a.isCanceled())||(_a.isValid&&!_a.isValid(_b))){
+_7.splice(i--,1);
+_d._onAction&&_d._onAction();
+}else{
+if(_a.isReady&&_a.isReady(_b)){
+_7.splice(i--,1);
+_a.handleResponse(_b);
+_d._onAction&&_d._onAction();
+}else{
+if(_a.startTime){
+if(_a.startTime+(_c.timeout||0)<_9){
+_7.splice(i--,1);
+_a.cancel(new _2(_b));
+_d._onAction&&_d._onAction();
+}
+}
+}
+}
+}
+_d._onInFlight&&_d._onInFlight(_a);
+if(!_7.length){
+clearInterval(_6);
+_6=null;
+}
+};
+function _d(_e){
+if(_e.response.options.timeout){
+_e.startTime=+(new Date);
+}
+if(_e.isFulfilled()){
+return;
+}
+_7.push(_e);
+if(!_6){
+_6=setInterval(_8,50);
+}
+if(_e.response.options.sync){
+_8();
+}
+};
+_d.cancelAll=function cancelAll(){
+try{
+_4.forEach(_7,function(_f){
+try{
+_f.cancel(new _3("All requests canceled."));
+}
+catch(e){
+}
+});
+}
+catch(e){
+}
+};
+if(_5&&on&&_5.doc.attachEvent){
+on(_5.global,"unload",function(){
+_d.cancelAll();
+});
+}
+return _d;
+});

data/vendor/assets/javascripts/dojo/request/watch.js.uncompressed.js

@@ -0,0 +1,109 @@
+define("dojo/request/watch", [
+	'./util',
+	'../errors/RequestTimeoutError',
+	'../errors/CancelError',
+	'../_base/array',
+	'../_base/window',
+	'../has!host-browser?dom-addeventlistener?:../on:'
+], function(util, RequestTimeoutError, CancelError, array, win, on){
+	// avoid setting a timer per request. It degrades performance on IE
+	// something fierece if we don't use unified loops.
+	var _inFlightIntvl = null,
+		_inFlight = [];
+
+	function watchInFlight(){
+		// summary:
+		//		internal method that checks each inflight XMLHttpRequest to see
+		//		if it has completed or if the timeout situation applies.
+
+		var now = +(new Date);
+
+		// we need manual loop because we often modify _inFlight (and therefore 'i') while iterating
+		for(var i = 0, dfd; i < _inFlight.length && (dfd = _inFlight[i]); i++){
+			var response = dfd.response,
+				options = response.options;
+			if((dfd.isCanceled && dfd.isCanceled()) || (dfd.isValid && !dfd.isValid(response))){
+				_inFlight.splice(i--, 1);
+				watch._onAction && watch._onAction();
+			}else if(dfd.isReady && dfd.isReady(response)){
+				_inFlight.splice(i--, 1);
+				dfd.handleResponse(response);
+				watch._onAction && watch._onAction();
+			}else if(dfd.startTime){
+				// did we timeout?
+				if(dfd.startTime + (options.timeout || 0) < now){
+					_inFlight.splice(i--, 1);
+					// Cancel the request so the io module can do appropriate cleanup.
+					dfd.cancel(new RequestTimeoutError(response));
+					watch._onAction && watch._onAction();
+				}
+			}
+		}
+
+		watch._onInFlight && watch._onInFlight(dfd);
+
+		if(!_inFlight.length){
+			clearInterval(_inFlightIntvl);
+			_inFlightIntvl = null;
+		}
+	}
+
+	function watch(dfd){
+		// summary:
+		//		Watches the io request represented by dfd to see if it completes.
+		// dfd: Deferred
+		//		The Deferred object to watch.
+		// response: Object
+		//		The object used as the value of the request promise.
+		// validCheck: Function
+		//		Function used to check if the IO request is still valid. Gets the dfd
+		//		object as its only argument.
+		// ioCheck: Function
+		//		Function used to check if basic IO call worked. Gets the dfd
+		//		object as its only argument.
+		// resHandle: Function
+		//		Function used to process response. Gets the dfd
+		//		object as its only argument.
+		if(dfd.response.options.timeout){
+			dfd.startTime = +(new Date);
+		}
+
+		if(dfd.isFulfilled()){
+			// bail out if the deferred is already fulfilled
+			return;
+		}
+
+		_inFlight.push(dfd);
+		if(!_inFlightIntvl){
+			_inFlightIntvl = setInterval(watchInFlight, 50);
+		}
+
+		// handle sync requests separately from async:
+		// http://bugs.dojotoolkit.org/ticket/8467
+		if(dfd.response.options.sync){
+			watchInFlight();
+		}
+	}
+
+	watch.cancelAll = function cancelAll(){
+		// summary:
+		//		Cancels all pending IO requests, regardless of IO type
+		try{
+			array.forEach(_inFlight, function(dfd){
+				try{
+					dfd.cancel(new CancelError('All requests canceled.'));
+				}catch(e){}
+			});
+		}catch(e){}
+	};
+
+	if(win && on && win.doc.attachEvent){
+		// Automatically call cancel all io calls on unload in IE
+		// http://bugs.dojotoolkit.org/ticket/2357
+		on(win.global, 'unload', function(){
+			watch.cancelAll();
+		});
+	}
+
+	return watch;
+});

data/vendor/assets/javascripts/dojo/request/xhr.js

@@ -0,0 +1,184 @@
+/*
+	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/request/xhr",["../errors/RequestError","./watch","./handlers","./util","../has"],function(_1,_2,_3,_4,_5){
+_5.add("native-xhr",function(){
+return typeof XMLHttpRequest!=="undefined";
+});
+_5.add("dojo-force-activex-xhr",function(){
+return _5("activex")&&!document.addEventListener&&window.location.protocol==="file:";
+});
+_5.add("native-xhr2",function(){
+if(!_5("native-xhr")){
+return;
+}
+var x=new XMLHttpRequest();
+return typeof x["addEventListener"]!=="undefined"&&(typeof opera==="undefined"||typeof x["upload"]!=="undefined");
+});
+_5.add("native-formdata",function(){
+return typeof FormData==="function";
+});
+function _6(_7,_8){
+var _9=_7.xhr;
+_7.status=_7.xhr.status;
+_7.text=_9.responseText;
+if(_7.options.handleAs==="xml"){
+_7.data=_9.responseXML;
+}
+if(!_8){
+try{
+_3(_7);
+}
+catch(e){
+_8=e;
+}
+}
+if(_8){
+this.reject(_8);
+}else{
+if(_4.checkStatus(_9.status)){
+this.resolve(_7);
+}else{
+_8=new _1("Unable to load "+_7.url+" status: "+_9.status,_7);
+this.reject(_8);
+}
+}
+};
+var _a,_b,_c,_d;
+if(_5("native-xhr2")){
+_a=function(_e){
+return !this.isFulfilled();
+};
+_d=function(_f,_10){
+_10.xhr.abort();
+};
+_c=function(_11,dfd,_12){
+function _13(evt){
+dfd.handleResponse(_12);
+};
+function _14(evt){
+var _15=evt.target;
+var _16=new _1("Unable to load "+_12.url+" status: "+_15.status,_12);
+dfd.handleResponse(_12,_16);
+};
+function _17(evt){
+if(evt.lengthComputable){
+_12.loaded=evt.loaded;
+_12.total=evt.total;
+dfd.progress(_12);
+}
+};
+_11.addEventListener("load",_13,false);
+_11.addEventListener("error",_14,false);
+_11.addEventListener("progress",_17,false);
+return function(){
+_11.removeEventListener("load",_13,false);
+_11.removeEventListener("error",_14,false);
+_11.removeEventListener("progress",_17,false);
+};
+};
+}else{
+_a=function(_18){
+return _18.xhr.readyState;
+};
+_b=function(_19){
+return 4===_19.xhr.readyState;
+};
+_d=function(dfd,_1a){
+var xhr=_1a.xhr;
+var _1b=typeof xhr.abort;
+if(_1b==="function"||_1b==="object"||_1b==="unknown"){
+xhr.abort();
+}
+};
+}
+var _1c,_1d={data:null,query:null,sync:false,method:"GET",headers:{"Content-Type":"application/x-www-form-urlencoded"}};
+function xhr(url,_1e,_1f){
+var _20=_4.parseArgs(url,_4.deepCreate(_1d,_1e),_5("native-formdata")&&_1e&&_1e.data&&_1e.data instanceof FormData);
+url=_20.url;
+_1e=_20.options;
+var _21,_22=function(){
+_21&&_21();
+};
+var dfd=_4.deferred(_20,_d,_a,_b,_6,_22);
+var _23=_20.xhr=xhr._create();
+if(!_23){
+dfd.cancel(new _1("XHR was not created"));
+return _1f?dfd:dfd.promise;
+}
+_20.getHeader=function(_24){
+return this.xhr.getResponseHeader(_24);
+};
+if(_c){
+_21=_c(_23,dfd,_20);
+}
+var _25=_1e.data,_26=!_1e.sync,_27=_1e.method;
+try{
+_23.open(_27,url,_26,_1e.user||_1c,_1e.password||_1c);
+if(_1e.withCredentials){
+_23.withCredentials=_1e.withCredentials;
+}
+var _28=_1e.headers,_29;
+if(_28){
+for(var hdr in _28){
+if(hdr.toLowerCase()==="content-type"){
+_29=_28[hdr];
+}else{
+if(_28[hdr]){
+_23.setRequestHeader(hdr,_28[hdr]);
+}
+}
+}
+}
+if(_29&&_29!==false){
+_23.setRequestHeader("Content-Type",_29);
+}
+if(!_28||!("X-Requested-With" in _28)){
+_23.setRequestHeader("X-Requested-With","XMLHttpRequest");
+}
+if(_4.notify){
+_4.notify.emit("send",_20,dfd.promise.cancel);
+}
+_23.send(_25);
+}
+catch(e){
+dfd.reject(e);
+}
+_2(dfd);
+_23=null;
+return _1f?dfd:dfd.promise;
+};
+xhr._create=function(){
+throw new Error("XMLHTTP not available");
+};
+if(_5("native-xhr")&&!_5("dojo-force-activex-xhr")){
+xhr._create=function(){
+return new XMLHttpRequest();
+};
+}else{
+if(_5("activex")){
+try{
+new ActiveXObject("Msxml2.XMLHTTP");
+xhr._create=function(){
+return new ActiveXObject("Msxml2.XMLHTTP");
+};
+}
+catch(e){
+try{
+new ActiveXObject("Microsoft.XMLHTTP");
+xhr._create=function(){
+return new ActiveXObject("Microsoft.XMLHTTP");
+};
+}
+catch(e){
+}
+}
+}
+}
+_4.addCommonMethods(xhr);
+return xhr;
+});