dojox-rails 0.13.0 → 0.14.0

data/vendor/assets/javascripts/dojox/io/OAuth.js.uncompressed.js

@@ -1,302 +0,0 @@
-define("dojox/io/OAuth", [
-	"dojo/_base/kernel", // dojo
-	"dojo/_base/lang", // mixin
-	"dojo/_base/array", // isArray, map
-	"dojo/_base/xhr", // formToObject, queryToObject, xhr
-	"dojo/dom", // byId
-	"dojox/encoding/digests/SHA1" // SHA1
-], function(dojo, lang, array, xhr, dom, SHA1){
-dojo.getObject("io.OAuth", true, dojox);
-
-dojox.io.OAuth = new (function(){
-	// summary:
-	//		Helper singleton for signing any kind of Ajax request using the OAuth 1.0 protocol.
-	// description:
-	//		dojox.io.OAuth is a singleton class designed to allow anyone to sign a request,
-	//		based on the OAuth 1.0 specification, made with any of the Dojo Toolkit's Ajax
-	//		methods (such as dojo.xhr[verb], dojo.io.iframe, etc.).
-	//
-	//		The main method of dojox.io.OAuth is the sign method (see documentation for .sign);
-	//		the idea is that you will "sign" the kwArgs object you'd normally pass to any of
-	//		the Ajax methods, and then pass the signed object along.  As long as the token
-	//		object used is valid (and the client's date and time are synced with a public
-	//		time server), a signed object should be passed along correctly.
-	//
-	//		dojox.io.OAuth does not deal with the OAuth handshake process at all.
-	//
-	//		This object was developed against the Netflix API (OAuth-based service); see
-	//		http://developer.netflix.com for more details.
-	var encode = this.encode = function(s){
-		if(!("" + s).length){ return ""; }
-		return encodeURIComponent(s)
-			.replace(/\!/g, "%21")
-			.replace(/\*/g, "%2A")
-			.replace(/\'/g, "%27")
-			.replace(/\(/g, "%28")
-			.replace(/\)/g, "%29");
-	};
-
-	var decode = this.decode = function(str){
-		// summary:
-		//		Break apart the passed string and decode.
-		//		Some special cases are handled.
-		var a=[], list=str.split("&");
-		for(var i=0, l=list.length; i<l; i++){
-			var item=list[i];
-			if(list[i]==""){ continue; }	//	skip this one.
-			if(list[i].indexOf("=")>-1){
-				var tmp=list[i].split("=");
-				a.push([ decodeURIComponent(tmp[0]), decodeURIComponent(tmp[1]) ]);
-			} else {
-				a.push([ decodeURIComponent(list[i]), null ]);
-			}
-		}
-		return a;
-	};
-
-	function parseUrl(url){
-		// summary:
-		//		Create a map out of the passed URL.  Need to pull any
-		//		query string parameters off the URL for the base signature string.
-        var keys = [
-				"source","protocol","authority","userInfo",
-				"user","password","host","port",
-				"relative","path","directory",
-				"file","query","anchor"
-			],
-			parser=/^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*):?([^:@]*))?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
-			match=parser.exec(url),
-			map = {},
-			i=keys.length;
-
-		//	create the base map first.
-		while(i--){ map[keys[i]] = match[i] || ""; }
-
-		//	create the normalized version of the url and add it to the map
-		var p=map.protocol.toLowerCase(),
-			a=map.authority.toLowerCase(),
-			b=(p=="http"&&map.port==80)||(p=="https"&&map.port==443);
-		if(b){
-			if(a.lastIndexOf(":")>-1){
-				a=a.substring(0, a.lastIndexOf(":"));
-			}
-		}
-		var path=map.path||"/";
-		map.url=p+"://"+a+path;
-
-		//	return the map
-		return map;
-	}
-
-	var tab="0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
-	function nonce(length){
-		var s="", tl=tab.length;
-		for(var i=0; i<length; i++){
-			s+=tab.charAt(Math.floor(Math.random()*tl));
-		}
-		return s;
-	}
-	function timestamp(){
-		return Math.floor(new Date().valueOf()/1000)-2;
-	}
-	function signature(data, key, type){
-		if(type && type!="PLAINTEXT" && type!="HMAC-SHA1"){
-			throw new Error("dojox.io.OAuth: the only supported signature encodings are PLAINTEXT and HMAC-SHA1.");
-		}
-
-		if(type=="PLAINTEXT"){
-			return key;
-		} else {
-			//	assume SHA1 HMAC
-			return SHA1._hmac(data, key);
-		}
-	}
-
-	function key(args){
-		// summary:
-		//		return the key used to sign a message based on the token object.
-		return encode(args.consumer.secret)
-			+ "&"
-			+ (args.token && args.token.secret ? encode(args.token.secret) : "");
-	}
-
-	function addOAuth(/* dojo.__XhrArgs */args, /* dojox.io.__OAuthArgs */oaa){
-		// summary:
-		//		Add the OAuth parameters to the query string/content.
-		var o = {
-			oauth_consumer_key: oaa.consumer.key,
-			oauth_nonce: nonce(16),
-			oauth_signature_method: oaa.sig_method || "HMAC-SHA1",
-			oauth_timestamp: timestamp(),
-			oauth_version: "1.0"
-		}
-		if(oaa.token){
-			o.oauth_token = oaa.token.key;
-		}
-		args.content = dojo.mixin(args.content||{}, o);
-	}
-
-	function convertArgs(args){
-		// summary:
-		//		Because of the need to create a base string, we have to do
-		//		some manual args preparation instead of relying on the internal
-		//		Dojo xhr functions.  But we'll let dojo.xhr assemble things
-		//		as it normally would.
-		var miArgs = [{}], formObject;
-
-		if(args.form){
-			if(!args.content){ args.content = {}; }
-			var form = dojo.byId(args.form);
-			var actnNode = form.getAttributeNode("action");
-			args.url = args.url || (actnNode ? actnNode.value : null);
-			formObject = dojo.formToObject(form);
-			delete args.form;
-		}
-		if(formObject){ miArgs.push(formObject); }
-		if(args.content){ miArgs.push(args.content); }
-
-		//	pull anything off the query string
-		var map = parseUrl(args.url);
-		if(map.query){
-			var tmp = dojo.queryToObject(map.query);
-			//	re-encode the values.  sigh
-			for(var p in tmp){ tmp[p] = encodeURIComponent(tmp[p]); }
-			miArgs.push(tmp);
-		}
-		args._url = map.url;
-
-		//	now set up all the parameters as an array of 2 element arrays.
-		var a = [];
-		for(var i=0, l=miArgs.length; i<l; i++){
-			var item=miArgs[i];
-			for(var p in item){
-				if(dojo.isArray(item[p])){
-					//	handle multiple values
-					for(var j=0, jl=item.length; j<jl; j++){
-						a.push([ p, item[j] ]);
-					}
-				} else {
-					a.push([ p, item[p] ]);
-				}
-			}
-		}
-
-		args._parameters = a;
-		return args;
-	}
-
-	function baseString(/* String */method, /* dojo.__XhrArgs */args, /* dojox.io.__OAuthArgs */oaa){
-		//	create and return the base string out of the args.
-		addOAuth(args, oaa);
-		convertArgs(args);
-
-		var a = args._parameters;
-
-		//	sort the parameters
-		a.sort(function(a,b){
-			if(a[0]>b[0]){ return 1; }
-			if(a[0]<b[0]){ return -1; }
-			if(a[1]>b[1]){ return 1; }
-			if(a[1]<b[1]){ return -1; }
-			return 0;
-		});
-
-		//	encode.
-		var s = dojo.map(a, function(item){
-			return encode(item[0]) + "=" + encode((""+item[1]).length ? item[1] : "");
-		}).join("&");
-
-		var baseString = method.toUpperCase()
-			+ "&" + encode(args._url)
-			+ "&" + encode(s);
-		return baseString;
-	}
-
-	function sign(method, args, oaa){
-		//	return the oauth_signature for this message.
-		var k = key(oaa),
-			message = baseString(method, args, oaa),
-			s = signature(message, k, oaa.sig_method || "HMAC-SHA1");
-		args.content["oauth_signature"] = s;
-		return args;
-	}
-	
-	/*=====
-	 	dojox.io.OAuth.__AccessorArgs = {
-			// key: String
-			//		The key or token issued to either the consumer or by the OAuth service.
-			// secret: String
-			//		The secret (shared secret for consumers, issued secret by OAuth service).
-		};
-		dojox.io.OAuth.__OAuthArgs = {
-			// consumer: dojox.io.OAuth.__AccessorArgs
-			//		The consumer information issued to your OpenAuth application.
-			// sig_method: String
-			//		The method used to create the signature.  Should be PLAINTEXT or HMAC-SHA1.
-			// token: dojox.io.OAuth.__AccessorArgs?
-			//		The request token and secret issued by the OAuth service.  If not
-			//		issued yet, this should be null.
-		};
-	=====*/
-
-	/*
-	 *	Process goes something like this:
-	 *	1. prepare the base string
-	 *	2. create the key
-	 *	3. create the signature based on the base string and the key
-	 *	4. send the request using dojo.xhr[METHOD].
-	 */
-
-	this.sign = function(/* String*/method, /* dojo.__XhrArgs */args, /* dojox.io.OAuth.__OAuthArgs */oaa){
-		// summary:
-		//		Given the OAuth access arguments, sign the kwArgs that you would pass
-		//		to any dojo Ajax method (dojo.xhr*, dojo.io.iframe, dojo.io.script).
-		// example:
-		//		Sign the kwArgs object for use with dojo.xhrGet:
-		//	|	var oaa = {
-		//	|		consumer: {
-		//	|			key: "foobar",
-		//	|			secret: "barbaz"
-		//	|		}
-		//	|	};
-		//	|
-		//	|	var args = dojox.io.OAuth.sign("GET", myAjaxKwArgs, oaa);
-		//	|	dojo.xhrGet(args);
-		return sign(method, args, oaa);
-	};
-
-
-	//	TODO: handle redirect requests?
-	this.xhr = function(/* String */method, /* dojo.__XhrArgs */args, /* dojox.io.OAuth.__OAuthArgs */oaa, /* Boolean? */hasBody){
-		/*	summary:
-		 *		Make an XHR request that is OAuth signed.
-		 *	example:
-		 *	|	var dfd = dojox.io.OAuth.xhrGet({
-		 *	|		url: "http://someauthdomain.com/path?foo=bar",
-		 *	|		load: function(response, ioArgs){ }
-		 *	|	},
-		 *	|	{
-		 *	|		consumer:{ key: "lasdkf9asdnfsdf", secret: "9asdnfskdfysjr" }
-		 *	|	});
-		 */
-		sign(method, args, oaa);
-		return xhr(method, args, hasBody);
-	};
-
-	this.xhrGet = function(/* dojo.__XhrArgs */args, /* dojox.io.OAuth.__OAuthArgs*/ oaa){
-		return this.xhr("GET", args, oaa);
-	};
-	this.xhrPost = this.xhrRawPost = function(/* dojo.__XhrArgs */args, /* dojox.io.OAuth.__OAuthArgs*/ oaa){
-		return this.xhr("POST", args, oaa, true);
-	};
-	this.xhrPut = this.xhrRawPut = function(/* dojo.__XhrArgs */args, /* dojox.io.OAuth.__OAuthArgs*/ oaa){
-		return this.xhr("PUT", args, oaa, true);
-	};
-	this.xhrDelete = function(/* dojo.__XhrArgs */args, /* dojox.io.OAuth.__OAuthArgs*/ oaa){
-		return this.xhr("DELETE", args, oaa);
-	};
-})();
-
-return dojox.io.OAuth;
-
-});

data/vendor/assets/javascripts/dojox/io/README

@@ -1,82 +0,0 @@
--------------------------------------------------------------------------------
-DojoX IO
--------------------------------------------------------------------------------
-Version 0.4.0
-Release date: 07/04/2008
--------------------------------------------------------------------------------
-Project state:
-experimental
--------------------------------------------------------------------------------
-Credits
-	Bryan Forbes (bryan AT reigndropsfall.net)
-	Kris Zyp (kris AT sitepen.com)
-	James Burke (jburke AT dojotoolkit.org)
-	Tom Trenka (ttrenka AT gmail.com)
-	
--------------------------------------------------------------------------------
-Project description
-
-	A Collection of advanced and experimental IO modules:
-	
-	* scriptFrame.js - Uses an iframe for dojo.io.script requests. Useful in some
-	long-polling comet situations in Firefox and Opera. Those browsers execute scripts
-	in DOM order, not network-receive order, so a long-polling script will block other
-	dynamically appended scripts from running until it completes. By using an iframe
-	for the dojo.io.script requests, this issue can be avoided.
-
-	* xhrMultiPart.js - Constructs multi-part mime XHR requests. Useful when wanting
-	multi-part requests but not using a form with a file input. Note that it does not
-	allow you to send files from local disks -- a form with a file input is required
-	for that use case. xhrMultipart is not useful in that use case.
-
-	* xhrPlugins.js - An adapter registry for having multiple XHR handlers (like
-	XDomainRequest, CS-XHR, proxy, and window.name)
-
-	* windowName.js - Cross-domain transport using window.name
-	xhrWindowNamePlugin.js - window.name plugin for XHR adapter registry
-
-	* httpParse.js - HTTP message parser. Parses to an XHR like interface.
-	
-	* OAuth.js - Object to be used for signing OpenAuth requests.  Includes easy
-		wrappers for xhr.
-	
--------------------------------------------------------------------------------
-Dependencies:
-
-DojoX IO xhrMultiPart depends on Dojo Core and DojoX UUID's generateRandomUuid 
-function.
-
-xhrWindowNamePlugin depends on dojox.secure.capability for safe JSON parsing
-
-OAuth depends on dojox.encoding.digests.SHA1.
--------------------------------------------------------------------------------
-Documentation
-
--------------------------------------------------------------------------------
-Installation instructions
-
-Grab the following from the Dojo SVN Repository:
-http://svn.dojotoolkit.org/var/src/dojo/dojox/trunk/uuid.js
-http://svn.dojotoolkit.org/var/src/dojo/dojox/trunk/uuid/*
-http://svn.dojotoolkit.org/var/src/dojo/dojox/trunk/secure/*
-http://svn.dojotoolkit.org/var/src/dojo/dojox/trunk/encoding/digests/*
-
-Install into the following directory structure:
-/dojox/uuid/
-/dojox/secure/
-/dojox/encoding/digests/
-
-AND
-
-Grab the following from the Dojo SVN Repository:
-http://svn.dojotoolkit.org/var/src/dojo/dojox/trunk/io/*
-
-Install into the following directory structure:
-/dojox/io/
-
-...both of which should be at the same level as your Dojo checkout.
--------------------------------------------------------------------------------
-Additional Notes
-
-The information contained in this README does not pertain to DojoX XHR IFrame Proxy.  
-For that information see proxy/README.

data/vendor/assets/javascripts/dojox/io/proxy/README

@@ -1,82 +0,0 @@
--------------------------------------------------------------------------------
-Project Name
--------------------------------------------------------------------------------
-Version 0.6
-Release date: 01/31/2008
--------------------------------------------------------------------------------
-Project state:
-experimental
--------------------------------------------------------------------------------
-Credits
-	James Burke (jburke@dojotoolkit.org)
--------------------------------------------------------------------------------
-Project description
-
-The XHR IFrame Proxy (xip) allows you to do cross-domain XMLHttpRequests (XHRs).
-It works by using two iframes, one your domain (xip_client.html), one on the 
-other domain (xip_server.html). They use fragment IDs in the iframe URLs to pass
-messages to each other. The xip.js file defines dojox.io.proxy.xip. This module
-intercepts XHR calls made by the Dojo XHR methods (dojo.xhr* methods). The module
-returns a facade object that acts like an XHR object. Once send is called on the
-facade, the facade's data is serialized, given to xip_client.html. xip_client.html
-then passes the serialized data to xip_server.html by changing xip_server.html's
-URL fragment ID (the #xxxx part of an URL). xip_server.html deserializes the
-message fragments, and does an XHR call, gets the response, and serializes the
-data. The serialized data is then passed back to xip_client.html by changing
-xip_client.html's fragment ID. Then the response is deserialized and used as
-the response inside the facade XHR object that was created by dojox.io.proxy.xip.
--------------------------------------------------------------------------------
-Dependencies:
-
-xip.js: Dojo Core, dojox.data.dom
-xip_client.html: none
-xip_server.html: none (but see Additional Notes section)
--------------------------------------------------------------------------------
-Documentation
-
-There is some documentation that applies to the Dojo 0.4.x version of these files:
-http://dojotoolkit.org/book/dojo-book-0-4/part-5-connecting-pieces/i-o/cross-domain-xmlhttprequest-using-iframe-proxy
-
-The general theory still applies to this code, but the specifics are different
-for the Dojo 0.9+ codebase. Doc updates hopefully after the basic code is ported.
-
-The current implementation destroys the iframes used for a request after the request
-completes. This seems to cause a memory leak, particularly in IE. So, it is not
-suited for doing polling cross-domain requests.
--------------------------------------------------------------------------------
-Installation instructions
-
-Grab the following from the Dojox SVN Repository:
-http://svn.dojotoolkit.org/var/src/dojo/dojox/trunk/io/proxy/xip.js
-http://svn.dojotoolkit.org/var/src/dojo/dojox/trunk/io/proxy/xip_client.html
-
-Install into the following directory structure:
-/dojox/io/proxy/
-
-...which should be at the same level as your Dojo checkout.
-
-Grab the following from the Dojox SVN Repository:
-http://svn.dojotoolkit.org/var/src/dojo/dojox/trunk/io/proxy/xip_server.html
-
-and install it on the domain that you want to allow receiving cross-domain
-requests. Be sure to read the documentation, the Additional Notes below, and
-the in-file comments.
--------------------------------------------------------------------------------
-Additional Notes
-
-xip_client.html and xip_server.html do not work right away. You need to uncomment
-out the script tags in the files. Additionally, xip_server.html requires a JS file,
-isAllowed.js, to be defined. See the notes in xip_server.html for more informaiton.
-
-XDOMAIN BUILD INSTRUCTIONS:
-The dojox.io.proxy module requires some setup to use with an xdomain build.
-The xip_client.html file has to be served from the same domain as your web page.
-It cannot be served from the domain that has the xdomain build. Download xip_client.html
-and install it on your server. Then set djConfig.xipClientUrl to the local path
-of xip_client.html (just use a path, not a whole URL, since it will be on the same
-domain as the page). The path to the file should be the path relative to the web
-page that is using dojox.io.proxy.
-
-
-
-