1 /*

     2 Copyright (c) 2009, Yahoo! Inc. All rights reserved.

     3 Code licensed under the BSD License:

     4 http://developer.yahoo.net/yui/license.txt

     5 version: 3.0.0

     6 build: 1549

     7 */

     8 YUI.add('io-base', function(Y) {

     9 

    10    /**

    11    	* Base IO functionality. Provides basic XHR transport support.

    12    	* @module io

    13    	* @submodule io-base

    14    	*/

    15 

    16    /**

    17 	* The io class is a utility that brokers HTTP requests through a simplified

    18 	* interface.  Specifically, it allows JavaScript to make HTTP requests to

    19 	* a resource without a page reload.  The underlying transport for making

    20 	* same-domain requests is the XMLHttpRequest object.  YUI.io can also use

    21 	* Flash, if specified as a transport, for cross-domain requests.

    22 	*

    23    	* @class io

    24    	*/

    25 

    26    /**

    27    	* @event io:start

    28    	* @description This event is fired by YUI.io when a transaction is initiated.

    29    	* @type Event Custom

    30    	*/

    31    	var E_START = 'io:start',

    32 

    33    /**

    34    	* @event io:complete

    35    	* @description This event is fired by YUI.io when a transaction is complete.

    36    	* Response status and data are accessible, if available.

    37    	* @type Event Custom

    38    	*/

    39    	E_COMPLETE = 'io:complete',

    40 

    41    /**

    42    	* @event io:success

    43    	* @description This event is fired by YUI.io when a transaction is complete, and

    44    	* the HTTP status resolves to HTTP2xx.

    45    	* @type Event Custom

    46    	*/

    47    	E_SUCCESS = 'io:success',

    48 

    49    /**

    50    	* @event io:failure

    51    	* @description This event is fired by YUI.io when a transaction is complete, and

    52    	* the HTTP status resolves to HTTP4xx, 5xx and above.

    53    	* @type Event Custom

    54    	*/

    55    	E_FAILURE = 'io:failure',

    56 

    57    /**

    58    	* @event io:end

    59    	* @description This event signifies the end of the transaction lifecycle.  The

    60    	* transaction transport is destroyed.

    61    	* @type Event Custom

    62    	*/

    63    	E_END = 'io:end',

    64 

    65    	//--------------------------------------

    66    	//  Properties

    67    	//--------------------------------------

    68    /**

    69    	* @description A transaction counter that increments for each transaction.

    70    	*

    71    	* @property transactionId

    72    	* @private

    73    	* @static

    74    	* @type int

    75    	*/

    76    	transactionId = 0,

    77 

    78    /**

    79    	* @description Object of default HTTP headers to be initialized and sent

    80    	* for all transactions.

    81    	*

    82    	* @property _headers

    83    	* @private

    84    	* @static

    85    	* @type object

    86    	*/

    87    	_headers = {

    88    		'X-Requested-With' : 'XMLHttpRequest'

    89    	},

    90 

    91    /**

    92    	* @description Object that stores timeout values for any transaction with

    93    	* a defined "timeout" configuration property.

    94    	*

    95    	* @property _timeout

    96    	* @private

    97    	* @static

    98    	* @type object

    99    	*/

   100    	_timeout = {},

   101 

   102    	// Window reference

   103    	w = Y.config.win;

   104 

   105    	//--------------------------------------

   106    	//  Methods

   107    	//--------------------------------------

   108    /**

   109    	* @description Method for requesting a transaction. _io() is implemented as

   110    	* yui.io().  Each transaction may include a configuration object.  Its

   111    	* properties are:

   112    	*

   113    	* method: HTTP method verb (e.g., GET or POST). If this property is not

   114    	*         not defined, the default value will be GET.

   115    	*

   116    	* data: This is the name-value string that will be sent as the transaction

   117     *		data.  If the request is HTTP GET, the data become part of

   118     *		querystring. If HTTP POST, the data are sent in the message body.

   119    	*

   120    	* xdr: Defines the transport to be used for cross-domain requests.  By

   121    	*      setting this property, the transaction will use the specified

   122    	*      transport instead of XMLHttpRequest.  Currently, the only alternate

   123    	*      transport supported is Flash (e.g., { xdr: 'flash' }).

   124    	*

   125    	* form: This is a defined object used to process HTML form as data.  The

   126    	*       properties are:

   127    	*       {

   128    	*	      id: object, //HTML form object or id of HTML form

   129    	*         useDisabled: boolean, //Allow disabled HTML form field values

   130    	*                      to be sent as part of the data.

   131 	*       }

   132 	*

   133 	* on: This is a defined object used to create and handle specific

   134 	*     events during a transaction lifecycle.  These events will fire in

   135 	*     addition to the global io events. The events are:

   136 	*	  start - This event is fired when a request is sent to a resource.

   137 	*     complete - This event fires when the transaction is complete.

   138 	*     success - This event fires when the response status resolves to

   139 	*               HTTP 2xx.

   140 	*     failure - This event fires when the response status resolves to

   141 	*               HTTP 4xx, 5xx; and, for all transaction exceptions,

   142 	*               including aborted transactions and transaction timeouts.

   143 	*	  end -  This even is fired at the conclusion of the transaction

   144    	*			 lifecycle, after a success or failure resolution.

   145 	*

   146 	*     The properties are:

   147 	*     {

   148    	*       start: function(id, args){},

   149    	*       complete: function(id, responseobject, args){},

   150    	*       success: function(id, responseobject, args){},

   151    	*       failure: function(id, responseobject, args){},

   152    	*       end: function(id, args){}

   153    	*     }

   154    	*	  Each property can reference a function or be written as an

   155    	*     inline function.

   156    	*

   157    	*     context: Object reference for an event handler when it is implemented

   158    	*              as a method of a base object. Defining "context" will preserve

   159    	*              the proper reference of "this" used in the event handler.

   160    	*     headers: This is a defined object of client headers, as many as.

   161    	*              desired for the transaction.  These headers are sentThe object

   162    	*              pattern is:

   163    	*              {

   164    	*		         header: value

   165    	*              }

   166    	*

   167    	* timeout: This value, defined as milliseconds, is a time threshold for the

   168    	*          transaction. When this threshold is reached, and the transaction's

   169    	*          Complete event has not yet fired, the transaction will be aborted.

   170    	* arguments: Object, array, string, or number passed to all registered

   171    	*            event handlers.  This value is available as the second

   172    	*            argument in the "start" and "abort" event handlers; and, it is

   173    	*            the third argument in the "complete", "success", and "failure"

   174    	*            event handlers.

   175    	*

   176    	* @method _io

   177    	* @private

   178    	* @static

   179 	* @param {string} uri - qualified path to transaction resource.

   180 	* @param {object} c - configuration object for the transaction.

   181 	* @param {number} i - transaction id, if already set by queue.

   182 	* @return object

   183    	*/

   184    	function _io(uri, c, i) {

   185    		var f, o, m;

   186    			c = c || {};

   187    			o = _create(c.xdr || c.form, i);

   188    			m = c.method ? c.method.toUpperCase() : 'GET';

   189 

   190    		if (c.form) {

   191    			if (c.form.upload) {

   192    				return Y.io._upload(o, uri, c);

   193    			}

   194    			else {

   195 				f = Y.io._serialize(c.form, c.data);

   196 				if (m === 'POST') {

   197 					c.data = f;

   198 					_setHeader('Content-Type', 'application/x-www-form-urlencoded');

   199 				}

   200 				else if (m === 'GET') {

   201 					uri = _concat(uri, f);

   202 				}

   203 			}

   204 		}

   205 		else if (c.data && m === 'GET') {

   206 			uri = _concat(uri, c.data);

   207 		}

   208 

   209    		if (c.xdr) {

   210 			if (c.xdr.use === 'native' && window.XDomainRequest || c.xdr.use === 'flash') {

   211    				return Y.io.xdr(uri, o, c);

   212 			}

   213 			if (c.xdr.credentials) {

   214 				o.c.withCredentials = true;

   215 			}

   216    		}

   217 

   218    		o.c.onreadystatechange = function() { _readyState(o, c); };

   219    		try {

   220 			o.c.open(m, uri, true);

   221    		}

   222    		catch(e0){

   223 			if (c.xdr) {

   224 				// This exception is usually thrown by browsers

   225 				// that do not support native XDR transactions.

   226 				return _resend(o, uri, c);

   227 			}

   228 		}

   229 

   230    		if (c.data && m === 'POST') {

   231    			_setHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8');

   232    		}

   233 

   234    		_setHeaders(o.c, c.headers || {});

   235 		try {

   236 			// Using "null" will result in a POST request with

   237 			// no Content-Length defined.

   238 	   		o.c.send(c.data || '');

   239 		}

   240    		catch(e1) {

   241 			if (c.xdr) {

   242 				// This exception is usually thrown by browsers

   243 				// that do not support native XDR transactions.

   244 				return _resend(o, uri, c);

   245 			}

   246 		}

   247 

   248    		_ioStart(o.id, c);

   249    		// If config.timeout is defined, and the request is standard XHR,

   250    		// initialize timeout polling.

   251    		if (c.timeout) {

   252    			_startTimeout(o, c.timeout);

   253    		}

   254 

   255 		return {

   256 			id: o.id,

   257 			abort: function() {

   258 				return o.c ? _ioCancel(o, 'abort') : false;

   259 			},

   260 			isInProgress: function() {

   261 				return o.c ? o.c.readyState !== 4 && o.c.readyState !== 0 : false;

   262 	   		}

   263 		}

   264    	}

   265 

   266    /**

   267    	* @description Method for creating and subscribing transaction events.

   268    	*

   269    	* @method _subscribe

   270    	* @private

   271    	* @static

   272    	* @param {string} e - event to be published

   273    	* @param {object} c - configuration data subset for event subscription.

   274    	*

   275 	* @return void

   276    	*/

   277    	function _subscribe(e, c){

   278    		var evt = new Y.EventTarget().publish('transaction:' + e);

   279 		evt.subscribe(c.on[e], (c.context || Y), c.arguments);

   280 

   281    		return evt;

   282    	}

   283 

   284    /**

   285    	* @description Fires event "io:start" and creates, fires a

   286    	* transaction-specific start event, if config.on.start is

   287    	* defined.

   288    	*

   289    	* @method _ioStart

   290    	* @private

   291    	* @static

   292    	* @param {number} id - transaction id

   293    	* @param {object} c - configuration object for the transaction.

   294    	*

   295     * @return void

   296    	*/

   297    	function _ioStart(id, c) {

   298    		var evt;

   299    			// Set default value of argument c, property "on" to Object if

   300    			// the property is null or undefined.

   301    			c.on = c.on || {};

   302 

   303    		Y.fire(E_START, id);

   304    		if (c.on.start) {

   305    			evt = _subscribe('start', c);

   306    			evt.fire(id);

   307    		}

   308    	}

   309 

   310 

   311    /**

   312    	* @description Fires event "io:complete" and creates, fires a

   313    	* transaction-specific "complete" event, if config.on.complete is

   314    	* defined.

   315    	*

   316    	* @method _ioComplete

   317    	* @private

   318    	* @static

   319    	* @param {object} o - transaction object.

   320    	* @param {object} c - configuration object for the transaction.

   321    	*

   322     * @return void

   323    	*/

   324    	function _ioComplete(o, c) {

   325    		var evt,

   326 			r = o.status ? { status: 0, statusText: o.status } : o.c;

   327    			// Set default value of argument c, property "on" to Object if

   328    			// the property is null or undefined.

   329    			c.on = c.on || {};

   330 

   331    		Y.fire(E_COMPLETE, o.id, r);

   332    		if (c.on.complete) {

   333    			evt = _subscribe('complete', c);

   334    			evt.fire(o.id, r);

   335    		}

   336    	}

   337 

   338    /**

   339    	* @description Fires event "io:success" and creates, fires a

   340    	* transaction-specific "success" event, if config.on.success is

   341    	* defined.

   342    	*

   343    	* @method _ioSuccess

   344    	* @private

   345    	* @static

   346    	* @param {object} o - transaction object.

   347    	* @param {object} c - configuration object for the transaction.

   348    	*

   349     * @return void

   350    	*/

   351    	function _ioSuccess(o, c) {

   352    		var evt;

   353    			// Set default value of argument c, property "on" to Object if

   354    			// the property is null or undefined.

   355    			c.on = c.on || {};

   356 

   357    		Y.fire(E_SUCCESS, o.id, o.c);

   358    		if (c.on.success) {

   359    			evt = _subscribe('success', c);

   360    			evt.fire(o.id, o.c);

   361    		}

   362 

   363    		_ioEnd(o, c);

   364    	}

   365 

   366    /**

   367    	* @description Fires event "io:failure" and creates, fires a

   368    	* transaction-specific "failure" event, if config.on.failure is

   369    	* defined.

   370    	*

   371    	* @method _ioFailure

   372    	* @private

   373    	* @static

   374    	* @param {object} o - transaction object.

   375    	* @param {object} c - configuration object for the transaction.

   376    	*

   377     * @return void

   378    	*/

   379    	function _ioFailure(o, c) {

   380    		var evt,

   381  			r = o.status ? { status: 0, statusText: o.status } : o.c;

   382    			// Set default value of argument c, property "on" to Object if

   383    			// the property is null or undefined.

   384    			c.on = c.on || {};

   385 

   386    		Y.fire(E_FAILURE, o.id, r);

   387    		if (c.on.failure) {

   388    			evt = _subscribe('failure', c);

   389    			evt.fire(o.id, r);

   390    		}

   391 

   392    		_ioEnd(o, c);

   393    	}

   394 

   395    /**

   396    	* @description Fires event "io:end" and creates, fires a

   397    	* transaction-specific "end" event, if config.on.end is

   398    	* defined.

   399    	*

   400    	* @method _ioEnd

   401    	* @private

   402    	* @static

   403    	* @param {object} o - transaction object.

   404    	* @param {object} c - configuration object for the transaction.

   405    	*

   406     * @return void

   407    	*/

   408    	function _ioEnd(o, c) {

   409    		var evt;

   410    			// Set default value of argument c, property "on" to Object if

   411    			// the property is null or undefined.

   412    			c.on = c.on || {};

   413 

   414    		Y.fire(E_END, o.id);

   415    		if (c.on.end) {

   416    			evt = _subscribe('end', c);

   417    			evt.fire(o.id);

   418    		}

   419 

   420    		_destroy(o, c.xdr ? true : false );

   421    	}

   422 

   423    /**

   424    	* @description Terminates a transaction due to an explicit abort or

   425    	* timeout.

   426    	*

   427    	* @method _ioCancel

   428    	* @private

   429    	* @static

   430 	* @param {object} o - Transaction object generated by _create().

   431 	* @param {string} s - Identifies timed out or aborted transaction.

   432    	*

   433     * @return void

   434    	*/

   435    	function _ioCancel(o, s) {

   436    		if (o && o.c) {

   437    			o.status = s;

   438    			o.c.abort();

   439    		}

   440    	}

   441 

   442    /**

   443    	* @description Resends an XDR transaction, using the Flash tranport,

   444    	* if the native transport fails.

   445    	*

   446    	* @method _resend

   447    	* @private

   448    	* @static

   449 

   450 	* @param {object} o - Transaction object generated by _create().

   451 	* @param {string} uri - qualified path to transaction resource.

   452    	* @param {object} c - configuration object for the transaction.

   453    	*

   454     * @return void

   455    	*/

   456 	function _resend(o, uri, c) {

   457 		var id = parseInt(o.id);

   458 

   459 		_destroy(o);

   460 		c.xdr.use = 'flash';

   461 

   462 		return Y.io(uri, c, id);

   463 	}

   464 

   465    /**

   466    	* @description Method that increments _transactionId for each transaction.

   467    	*

   468    	* @method _id

   469    	* @private

   470    	* @static

   471     * @return int

   472    	*/

   473    	function _id() {

   474    		var id = transactionId;

   475 

   476    		transactionId++;

   477 

   478    		return id;

   479    	}

   480 

   481    /**

   482    	* @description Method that creates a unique transaction object for each

   483    	* request.

   484    	*

   485    	* @method _create

   486    	* @private

   487    	* @static

   488 	* @param {number} c - configuration object subset to determine if

   489 	*                     the transaction is an XDR or file upload,

   490 	*                     requiring an alternate transport.

   491 	* @param {number} i - transaction id

   492 	* @return object

   493    	*/

   494    	function _create(c, i) {

   495    		var o = {};

   496 	   		o.id = Y.Lang.isNumber(i) ? i : _id();

   497 	   		c = c || {};

   498 

   499 		if (!c.use && !c.upload) {

   500    			o.c = _xhr();

   501 		}

   502    		else if (c.use) {

   503 			if (c.use === 'flash') {

   504    				o.c = Y.io._transport[c.use];

   505 			}

   506 			else if (c.use === 'native' && window.XDomainRequest) {

   507 				o.c = new XDomainRequest();

   508 			}

   509 			else {

   510 				o.c = _xhr();

   511 			}

   512    		}

   513    		else {

   514    			o.c = {};

   515    		}

   516 

   517    		return o;

   518    	};

   519 

   520    /**

   521    	* @description Method that creates the XMLHttpRequest transport

   522    	*

   523    	* @method _xhr

   524    	* @private

   525    	* @static

   526 	* @return object

   527    	*/

   528    	function _xhr() {

   529    		return w.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP');

   530    	}

   531 

   532    /**

   533    	* @description Method that concatenates string data for HTTP GET transactions.

   534    	*

   535    	* @method _concat

   536    	* @private

   537    	* @static

   538 	* @param {string} s - URI or root data.

   539 	* @param {string} d - data to be concatenated onto URI.

   540 	* @return int

   541    	*/

   542    	function _concat(s, d) {

   543    		s += ((s.indexOf('?') == -1) ? '?' : '&') + d;

   544    		return s;

   545    	}

   546 

   547    /**

   548    	* @description Method that stores default client headers for all transactions.

   549    	* If a label is passed with no value argument, the header will be deleted.

   550    	*

   551    	* @method _setHeader

   552    	* @private

   553    	* @static

   554 	* @param {string} l - HTTP header

   555 	* @param {string} v - HTTP header value

   556 	* @return int

   557    	*/

   558    	function _setHeader(l, v) {

   559    		if (v) {

   560    			_headers[l] = v;

   561    		}

   562    		else {

   563    			delete _headers[l];

   564    		}

   565    	}

   566 

   567    /**

   568    	* @description Method that sets all HTTP headers to be sent in a transaction.

   569    	*

   570    	* @method _setHeaders

   571    	* @private

   572    	* @static

   573 	* @param {object} o - XHR instance for the specific transaction.

   574 	* @param {object} h - HTTP headers for the specific transaction, as defined

   575 	*                     in the configuration object passed to YUI.io().

   576 	* @return void

   577    	*/

   578    	function _setHeaders(o, h) {

   579    		var p;

   580 

   581    		for (p in _headers) {

   582    			if (_headers.hasOwnProperty(p)) {

   583    				if (h[p]) {

   584    					// Configuration headers will supersede IO preset headers,

   585    					// if headers match.

   586    					break;

   587    				}

   588    				else {

   589    					h[p] = _headers[p];

   590    				}

   591    			}

   592    		}

   593 

   594    		for (p in h) {

   595    			if (h.hasOwnProperty(p)) {

   596    				o.setRequestHeader(p, h[p]);

   597    			}

   598    		}

   599    	}

   600 

   601    /**

   602    	* @description Starts timeout count if the configuration object

   603    	* has a defined timeout property.

   604    	*

   605    	* @method _startTimeout

   606    	* @private

   607    	* @static

   608 	* @param {object} o - Transaction object generated by _create().

   609 	* @param {object} c - Configuration object passed to YUI.io().

   610 	* @return void

   611    	*/

   612    	function _startTimeout(o, timeout) {

   613    		_timeout[o.id] = w.setTimeout(function() { _ioCancel(o, 'timeout'); }, timeout);

   614    	}

   615 

   616    /**

   617    	* @description Clears the timeout interval started by _startTimeout().

   618    	*

   619    	* @method _clearTimeout

   620    	* @private

   621    	* @static

   622 	* @param {number} id - Transaction id.

   623 	* @return void

   624    	*/

   625    	function _clearTimeout(id) {

   626    		w.clearTimeout(_timeout[id]);

   627    		delete _timeout[id];

   628    	}

   629 

   630    /**

   631    	* @description Event handler bound to onreadystatechange.

   632    	*

   633    	* @method _readyState

   634    	* @private

   635    	* @static

   636 	* @param {object} o - Transaction object generated by _create().

   637 	* @param {object} c - Configuration object passed to YUI.io().

   638 	* @return void

   639    	*/

   640    	function _readyState(o, c) {

   641    		if (o.c.readyState === 4) {

   642    			if (c.timeout) {

   643    				_clearTimeout(o.id);

   644    			}

   645 

   646    			w.setTimeout(

   647    				function() {

   648    					_ioComplete(o, c);

   649    					_handleResponse(o, c);

   650    				}, 0);

   651    		}

   652    	}

   653 

   654    /**

   655    	* @description Method that determines if a transaction response qualifies

   656    	* as success or failure, based on the response HTTP status code, and

   657    	* fires the appropriate success or failure events.

   658    	*

   659    	* @method _handleResponse

   660    	* @private

   661    	* @static

   662 	* @param {object} o - Transaction object generated by _create().

   663 	* @param {object} c - Configuration object passed to io().

   664 	* @return void

   665    	*/

   666    	function _handleResponse(o, c) {

   667    		var status;

   668    		try{

   669    			if (o.c.status && o.c.status !== 0) {

   670    				status = o.c.status;

   671    			}

   672    			else {

   673    				status = 0;

   674    			}

   675    		}

   676    		catch(e) {

   677    			status = 0;

   678    		}

   679 

   680    		// IE reports HTTP 204 as HTTP 1223.

   681    		if (status >= 200 && status < 300 || status === 1223) {

   682    			_ioSuccess(o, c);

   683    		}

   684    		else {

   685    			_ioFailure(o, c);

   686    		}

   687    	}

   688 

   689    	function _destroy(o, transport) {

   690    		// IE, when using XMLHttpRequest as an ActiveX Object, will throw

   691    		// a "Type Mismatch" error if the event handler is set to "null".

   692    		if(w.XMLHttpRequest && !transport) {

   693    			if (o.c) {

   694    				o.c.onreadystatechange = null;

   695    			}

   696    		}

   697 

   698    		o.c = null;

   699    		o = null;

   700    	}

   701 

   702    	_io.start = _ioStart;

   703 	_io.complete = _ioComplete;

   704    	_io.success = _ioSuccess;

   705    	_io.failure = _ioFailure;

   706    	_io.end = _ioEnd;

   707    	_io._id = _id;

   708    	_io._timeout = _timeout;

   709 

   710 	//--------------------------------------

   711 	//  Begin public interface definition

   712 	//--------------------------------------

   713    /**

   714    	* @description Method that stores default client headers for all transactions.

   715    	* If a label is passed with no value argument, the header will be deleted.

   716    	* This is the interface for _setHeader().

   717    	*

   718    	* @method header

   719    	* @public

   720    	* @static

   721 	* @param {string} l - HTTP header

   722 	* @param {string} v - HTTP header value

   723 	* @return int

   724    	*/

   725    	_io.header = _setHeader;

   726 

   727    /**

   728    	* @description Method for requesting a transaction. This

   729    	* is the interface for _io().

   730    	*

   731    	* @method io

   732    	* @public

   733    	* @static

   734     * @param {string} uri - qualified path to transaction resource.

   735     * @param {object} c - configuration object for the transaction.

   736     * @return object

   737     */

   738    	Y.io = _io;

   739 	Y.io.http = _io;

   740 

   741 

   742 

   743 }, '3.0.0' ,{requires:['event-custom-base']});

   744 

   745 YUI.add('io-form', function(Y) {

   746 

   747    /**

   748     * Extends the IO base class to enable HTML form data serialization, when specified

   749     * in the transaction's configuration object.

   750     * @module io

   751     * @submodule io-form

   752     */

   753 

   754     Y.mix(Y.io, {

   755        /**

   756         * @description Method to enumerate through an HTML form's elements collection

   757         * and return a string comprised of key-value pairs.

   758         *

   759         * @method _serialize

   760         * @private

   761         * @static

   762         * @param {object} c - YUI form node or HTML form id.

   763         * @param {string} s - Transaction data defined in the configuration.

   764         * @return string

   765         */

   766         _serialize: function(c, s) {

   767 			var eUC = encodeURIComponent,

   768             	data = [],

   769             	useDf = c.useDisabled || false,

   770             	item = 0,

   771             	id = (typeof c.id === 'string') ? c.id : c.id.getAttribute('id'),

   772             	e, f, n, v, d, i, il, j, jl, o;

   773 

   774             	if (!id) {

   775 					id = Y.guid('io:');

   776 					c.id.setAttribute('id', id);

   777 				}

   778 

   779             	f = Y.config.doc.getElementById(id);

   780 

   781             // Iterate over the form elements collection to construct the

   782             // label-value pairs.

   783             for (i = 0, il = f.elements.length; i < il; ++i) {

   784                 e = f.elements[i];

   785                 d = e.disabled;

   786                 n = e.name;

   787 

   788                 if ((useDf) ? n : (n && !d)) {

   789                     n = encodeURIComponent(n) + '=';

   790                     v = encodeURIComponent(e.value);

   791 

   792                     switch (e.type) {

   793                         // Safari, Opera, FF all default options.value from .text if

   794                         // value attribute not specified in markup

   795                         case 'select-one':

   796                             if (e.selectedIndex > -1) {

   797                                 o = e.options[e.selectedIndex];

   798                                 data[item++] = n + eUC((o.attributes.value && o.attributes.value.specified) ? o.value : o.text);

   799                             }

   800                             break;

   801                         case 'select-multiple':

   802                             if (e.selectedIndex > -1) {

   803                                 for (j = e.selectedIndex, jl = e.options.length; j < jl; ++j) {

   804                                     o = e.options[j];

   805                                     if (o.selected) {

   806                                       data[item++] = n + eUC((o.attributes.value && o.attributes.value.specified) ? o.value : o.text);

   807                                     }

   808                                 }

   809                             }

   810                             break;

   811                         case 'radio':

   812                         case 'checkbox':

   813                             if(e.checked){

   814                                 data[item++] = n + v;

   815                             }

   816                             break;

   817                         case 'file':

   818                             // stub case as XMLHttpRequest will only send the file path as a string.

   819                         case undefined:

   820                             // stub case for fieldset element which returns undefined.

   821                         case 'reset':

   822                             // stub case for input type reset button.

   823                         case 'button':

   824                             // stub case for input type button elements.

   825                             break;

   826                         case 'submit':

   827                         default:

   828                             data[item++] = n + v;

   829                     }

   830                 }

   831             }

   832             return s ? data.join('&') + "&" + s : data.join('&');

   833         }

   834     }, true);

   835 

   836 

   837 

   838 }, '3.0.0' ,{requires:['io-base','node-base','node-style']});

   839 

   840 YUI.add('io-xdr', function(Y) {

   841 

   842    /**

   843     * Extends the IO base class to provide an alternate, Flash transport, for making

   844     * cross-domain requests.

   845 	* @module io

   846 	* @submodule io-xdr

   847 	*/

   848 

   849    /**

   850 	* @event io:xdrReady

   851 	* @description This event is fired by YUI.io when the specified transport is

   852 	* ready for use.

   853 	* @type Event Custom

   854 	*/

   855 	var E_XDR_READY = 'io:xdrReady',

   856 

   857 

   858    /**

   859 	* @description Object that stores callback handlers for cross-domain requests

   860 	* when using Flash as the transport.

   861 	*

   862 	* @property _fn

   863 	* @private

   864 	* @static

   865 	* @type object

   866 	*/

   867 	_fn = {},

   868 

   869    /**

   870 	* @description Map of transaction state used when XDomainRequest is the

   871 	* XDR transport.

   872 	*

   873 	* @property _rS

   874 	* @private

   875 	* @static

   876 	* @type object

   877 	*/

   878 	_rS = {};

   879 

   880    /**

   881 	* @description Method that creates the Flash transport swf.

   882 	*

   883 	* @method _swf

   884 	* @private

   885 	* @static

   886 	* @param {string} uri - location of io.swf.

   887 	* @param {string} yid - YUI instance id.

   888 	* @return void

   889 	*/

   890 	function _swf(uri, yid) {

   891 		var o = '<object id="yuiIoSwf" type="application/x-shockwave-flash" data="' +

   892 		        uri + '" width="0" height="0">' +

   893 		     	'<param name="movie" value="' + uri + '">' +

   894 		     	'<param name="FlashVars" value="yid=' + yid + '">' +

   895                 '<param name="allowScriptAccess" value="always">' +

   896 		    	'</object>',

   897 		    c = document.createElement('div');

   898 

   899 		document.body.appendChild(c);

   900 		c.innerHTML = o;

   901 	}

   902 

   903    /**

   904 	* @description Sets event handlers for XDomainRequest transactions.

   905 	*

   906 	* @method _xdr

   907 	* @private

   908 	* @static

   909     * @param {object} o - Transaction object generated by _create() in io-base.

   910 	* @param {object} c - configuration object for the transaction.

   911 	* @return void

   912 	*/

   913 	function _xdr(o, c) {

   914 		o.c.onprogress = function() { _rS[o.id] = 3; }

   915 		o.c.onload = function() {

   916 			_rS[o.id] = 4;

   917 			Y.io.xdrResponse(o, c, 'success');

   918 		};

   919 		o.c.onerror = function() {

   920 			_rS[o.id] = 4;

   921 			Y.io.xdrResponse(o, c, 'failure');

   922 		};

   923 		if (c.timeout) {

   924 			o.c.ontimeout = function() {

   925 				_rS[o.id] = 4;

   926 				Y.io.xdrResponse(o, c, 'timeout');

   927 			};

   928 			o.c.timeout = c.timeout;

   929 		}

   930 	}

   931 

   932    /**

   933 	* @description Creates a response object for XDR transactions, for success

   934 	* and failure cases.

   935 	*

   936 	* @method _data

   937 	* @private

   938 	* @static

   939     * @param {object} o - Transaction object generated by _create() in io-base.

   940 	* @param {boolean} isFlash - True if Flash was used as the transport.

   941 	* @param {boolean} isXML - True if the response data are XML.

   942 	*

   943 	* @return object

   944 	*/

   945 	function _data(o, isFlash, isXML) {

   946 		var text, xml;

   947 

   948 		if (!o.status) {

   949 			text = isFlash ? decodeURI(o.c.responseText) : o.c.responseText;

   950 			xml = isXML ? Y.DataType.XML.parse(text) : null;

   951 

   952 			return { id: o.id, c: { responseText: text, responseXML: xml } };

   953 		}

   954 		else {

   955 			return { id: o.id, status: o.status };

   956 		}

   957 

   958 	}

   959 

   960    /**

   961 	* @description Method for intiating an XDR transaction abort.

   962 	*

   963 	* @method _abort

   964 	* @private

   965 	* @static

   966 	* @param {object} o - Transaction object generated by _create() in io-base.

   967 	* @param {object} c - configuration object for the transaction.

   968 	*/

   969 	function _abort(o, c) {

   970 		return c.xdr.use === 'flash' ? o.c.abort(o.id, c) : o.c.abort();

   971 	}

   972 

   973    /**

   974 	* @description Method for determining if an XDR transaction has completed

   975 	* and all data are received.

   976 	*

   977 	* @method _isInProgress.

   978 	* @private

   979 	* @static

   980 	* @param {object} o - Transaction object generated by _create() in io-base.

   981 	* @param {object} c - configuration object for the transaction.

   982 	*/

   983 	function _isInProgress(o, t) {

   984 		return (t === 'flash' && o.c) ? o.c.isInProgress(o.id) : _rS[o.id] !== 4;

   985 	}

   986 

   987     Y.mix(Y.io, {

   988 

   989 	   /**

   990 		* @description Map of io transports.

   991 		*

   992 		* @property _transport

   993 		* @private

   994 		* @static

   995 		* @type object

   996 		*/

   997 		_transport: {},

   998 

   999 	   /**

  1000 	   	* @description Method for accessing the transport's interface for making a

  1001 	   	* cross-domain transaction.

  1002 	   	*

  1003 		* @method _xdr

  1004 		* @private

  1005 		* @static

  1006 		* @param {string} uri - qualified path to transaction resource.

  1007     	* @param {object} o - Transaction object generated by _create() in io-base.

  1008 		* @param {object} c - configuration object for the transaction.

  1009 		*/

  1010 		xdr: function(uri, o, c) {

  1011 			if (c.on && c.xdr.use === 'flash') {

  1012 				_fn[o.id] = {

  1013 					on: c.on,

  1014 					context: c.context,

  1015 					arguments: c.arguments

  1016 				};

  1017 				// These nodes do not need to be serialized across Flash's

  1018 				// ExternalInterface.  Doing so will result in exceptions.

  1019 				c.context = null;

  1020 				c.form = null;

  1021 

  1022 				o.c.send(uri, c, o.id);

  1023 			}

  1024 			else if (window.XDomainRequest) {

  1025 				_xdr(o, c);

  1026 				o.c.open(c.method || 'GET', uri);

  1027 				o.c.send(c.data);

  1028 			}

  1029 

  1030 			return {

  1031 				id: o.id,

  1032 				abort: function() {

  1033 					return o.c ? _abort(o, c) : false;

  1034 				},

  1035 				isInProgress: function() {

  1036 					return o.c ? _isInProgress(o, c.xdr.use) : false;

  1037 				}

  1038 			}

  1039 		},

  1040 

  1041 	   /**

  1042 	   	* @description Response controller for cross-domain requests when using the

  1043 	   	* Flash transport or IE8's XDomainRequest object.

  1044 	   	*

  1045 		* @method xdrResponse

  1046 		* @private

  1047 		* @static

  1048     	* @param {object} o - Transaction object generated by _create() in io-base.

  1049 		* @param {object} c - configuration object for the transaction.

  1050 		* @param {string} e - Event name

  1051 		* @return object

  1052 		*/

  1053 		xdrResponse: function(o, c, e) {

  1054    			var m, fn,

  1055    				isFlash = c.xdr.use === 'flash' ? true : false,

  1056    				isXML = c.xdr.dataType === 'xml' ? true : false;

  1057    				c.on = c.on || {};

  1058 

  1059    			if (isFlash) {

  1060    				m = _fn || {};

  1061    				fn = m[o.id] ? m[o.id] : null;

  1062    				if (fn) {

  1063 	   				c.on = fn.on;

  1064 	   				c.context = fn.context;

  1065 	   				c.arguments = fn.arguments;

  1066 				}

  1067 			}

  1068 			if (e === ('abort' || 'timeout')) {

  1069 				o.status = e;

  1070 			}

  1071 

  1072 			switch (e) {

  1073 				case 'start':

  1074 					Y.io.start(o.id, c);

  1075 					break;

  1076 				case 'success':

  1077 					Y.io.success(_data(o, isFlash, isXML), c);

  1078 					isFlash ? delete m[o.id] : delete _rS[o.id];

  1079 					break;

  1080 				case 'timeout':

  1081 				case 'abort':

  1082 				case 'failure':

  1083 					Y.io.failure(_data(o, isFlash, isXML), c);

  1084 					isFlash ? delete m[o.id] : delete _rS[o.id];

  1085 					break;

  1086 			}

  1087 		},

  1088 

  1089 	   /**

  1090 		* @description Fires event "io:xdrReady"

  1091 		*

  1092 		* @method xdrReady

  1093 		* @private

  1094 		* @static

  1095 		* @param {number} id - transaction id

  1096 		* @param {object} c - configuration object for the transaction.

  1097 		*

  1098 		* @return void

  1099 		*/

  1100 		xdrReady: function(id) {

  1101 			Y.fire(E_XDR_READY, id);

  1102 		},

  1103 

  1104 	   /**

  1105 		* @description Method to initialize the desired transport.

  1106 		*

  1107 		* @method transport

  1108 		* @public

  1109 		* @static

  1110 		* @param {object} o - object of transport configurations.

  1111 		* @return void

  1112 		*/

  1113 		transport: function(o) {

  1114 			var id = o.yid ? o.yid : Y.id;

  1115 

  1116 			_swf(o.src, id);

  1117 			this._transport.flash = Y.config.doc.getElementById('yuiIoSwf');

  1118 		}

  1119 	});

  1120 

  1121 

  1122 

  1123 }, '3.0.0' ,{requires:['io-base','datatype-xml']});

  1124 

  1125 YUI.add('io-upload-iframe', function(Y) {

  1126 

  1127    /**

  1128    	* Extends the IO base class to enable file uploads, with HTML forms,

  1129    	* using an iframe as the transport medium.

  1130 	* @module io

  1131 	* @submodule io-upload-iframe

  1132 	*/

  1133 

  1134 	var w = Y.config.win;

  1135    /**

  1136 	* @description Parses the POST data object and creates hidden form elements