X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=src%2Fajax.js;h=bfae7824478b2090dcf5bfc3065519379e498c8d;hb=3dbd600e1961d9ab5296afbf2b3eb0852ad176e0;hp=81225f2cbf9597af5b2628daeac98e66944c3d6d;hpb=9e60fec46b2394541f75da3e333094d41069e84f;p=jquery.git diff --git a/src/ajax.js b/src/ajax.js index 81225f2..bf0259c 100644 --- a/src/ajax.js +++ b/src/ajax.js @@ -1,20 +1,28 @@ -var jsc = now(), - rscript = //g, - rselectTextarea = /select|textarea/i, - rinput = /text|hidden|password|search/i, - jsre = /=\?(&|$)/, +(function( jQuery ) { + +var r20 = /%20/g, + rbracket = /\[\]$/, + rhash = /#.*$/, + rheaders = /^(.*?):\s*(.*?)\r?$/mg, // IE leaves an \r character at EOL + rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i, + rnoContent = /^(?:GET|HEAD)$/, rquery = /\?/, - rts = /(\?|&)_=.*?(&|$)/, - rurl = /^(\w+:)?\/\/([^\/?#]+)/, - r20 = /%20/g; + rscript = /)<[^<]*)*<\/script>/gi, + rselectTextarea = /^(?:select|textarea)/i, + rts = /([?&])_=[^&]*/, + rurl = /^(\w+:)?\/\/([^\/?#:]+)(?::(\d+))?/, + rCRLF = /\r?\n/g, -jQuery.fn.extend({ - // Keep a copy of the old load - _load: jQuery.fn.load, + // Slice function + sliceFunc = Array.prototype.slice, + + // Keep a copy of the old load method + _load = jQuery.fn.load; +jQuery.fn.extend({ load: function( url, params, callback ) { - if ( typeof url !== "string" ) { - return this._load( url ); + if ( typeof url !== "string" && _load ) { + return _load.apply( this, arguments ); // Don't do a request if no elements are being requested } else if ( !this.length ) { @@ -40,38 +48,47 @@ jQuery.fn.extend({ // Otherwise, build a param string } else if ( typeof params === "object" ) { - params = jQuery.param( params ); + params = jQuery.param( params, jQuery.ajaxSettings.traditional ); type = "POST"; } } + var self = this; + // Request the remote document jQuery.ajax({ url: url, type: type, dataType: "html", data: params, - context:this, - complete: function(res, status){ + // Complete callback (responseText is used internally) + complete: function( jXHR, status, responseText ) { + // Store the response as specified by the jXHR object + responseText = jXHR.responseText; // If successful, inject the HTML into all the matched elements - if ( status === "success" || status === "notmodified" ) { + if ( jXHR.isResolved() ) { + // #4825: Get the actual response in case + // a dataFilter is present in ajaxSettings + jXHR.done(function( r ) { + responseText = r; + }); // See if a selector was specified - this.html( selector ? + self.html( selector ? // Create a dummy div to hold the results - jQuery("
") + jQuery("
") // inject the contents of the document in, removing the scripts // to avoid any 'Permission Denied' errors in IE - .append(res.responseText.replace(rscript, "")) + .append(responseText.replace(rscript, "")) // Locate the specified elements .find(selector) : // If not, just inject the full result - res.responseText ); + responseText ); } if ( callback ) { - this.each( callback, [res.responseText, status, res] ); + self.each( callback, [responseText, status, jXHR] ); } } }); @@ -82,6 +99,7 @@ jQuery.fn.extend({ serialize: function() { return jQuery.param(this.serializeArray()); }, + serializeArray: function() { return this.map(function(){ return this.elements ? jQuery.makeArray(this.elements) : this; @@ -98,9 +116,9 @@ jQuery.fn.extend({ null : jQuery.isArray(val) ? jQuery.map( val, function(val, i){ - return {name: elem.name, value: val}; + return { name: elem.name, value: val.replace(rCRLF, "\r\n") }; }) : - {name: elem.name, value: val}; + { name: elem.name, value: val.replace(rCRLF, "\r\n") }; }).get(); } }); @@ -112,9 +130,8 @@ jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".sp }; }); -jQuery.extend({ - - get: function( url, data, callback, type ) { +jQuery.each( [ "get", "post" ], function( i, method ) { + jQuery[ method ] = function( url, data, callback, type ) { // shift arguments if data argument was omited if ( jQuery.isFunction( data ) ) { type = type || callback; @@ -123,13 +140,16 @@ jQuery.extend({ } return jQuery.ajax({ - type: "GET", + type: method, url: url, data: data, success: callback, dataType: type }); - }, + }; +}); + +jQuery.extend({ getScript: function( url, callback ) { return jQuery.get(url, null, callback, "script"); @@ -139,25 +159,11 @@ jQuery.extend({ return jQuery.get(url, data, callback, "json"); }, - post: function( url, data, callback, type ) { - // shift arguments if data argument was omited - if ( jQuery.isFunction( data ) ) { - type = type || callback; - callback = data; - data = {}; - } - - return jQuery.ajax({ - type: "POST", - url: url, - data: data, - success: callback, - dataType: type - }); - }, - ajaxSetup: function( settings ) { - jQuery.extend( jQuery.ajaxSettings, settings ); + jQuery.extend( true, jQuery.ajaxSettings, settings ); + if ( settings.context ) { + jQuery.ajaxSettings.context = settings.context; + } }, ajaxSettings: { @@ -170,476 +176,775 @@ jQuery.extend({ /* timeout: 0, data: null, + dataType: null, username: null, password: null, + cache: null, + traditional: false, + headers: {}, + crossDomain: null, */ - // Create the request object; Microsoft failed to properly - // implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available - // This function can be overriden by calling jQuery.ajaxSetup - xhr: function(){ - return window.ActiveXObject ? - new ActiveXObject("Microsoft.XMLHTTP") : - new XMLHttpRequest(); - }, + accepts: { xml: "application/xml, text/xml", html: "text/html", - script: "text/javascript, application/javascript", - json: "application/json, text/javascript", text: "text/plain", - _default: "*/*" - } - }, + json: "application/json, text/javascript", + "*": "*/*" + }, - // Last-Modified header cache for next request - lastModified: {}, - etag: {}, + contents: { + xml: /xml/, + html: /html/, + json: /json/ + }, - ajax: function( origSettings ) { - var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings); - - var jsonp, status, data, - callbackContext = s.context || window, - type = s.type.toUpperCase(); + responseFields: { + xml: "responseXML", + text: "responseText" + }, - // convert data if not already a string - if ( s.data && s.processData && typeof s.data !== "string" ) { - s.data = jQuery.param(s.data); - } + // Prefilters + // 1) They are useful to introduce custom dataTypes (see transport/jsonp for an example) + // 2) These are called: + // * BEFORE asking for a transport + // * AFTER param serialization (s.data is a string if s.processData is true) + // 3) key is the dataType + // 4) the catchall symbol "*" can be used + // 5) execution will start with transport dataType and THEN continue down to "*" if needed + prefilters: {}, - // Handle JSONP Parameter Callbacks - if ( s.dataType === "jsonp" ) { - if ( type === "GET" ) { - if ( !jsre.test( s.url ) ) { - s.url += (rquery.test( s.url ) ? "&" : "?") + (s.jsonp || "callback") + "=?"; - } - } else if ( !s.data || !jsre.test(s.data) ) { - s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?"; - } - s.dataType = "json"; - } + // Transports bindings + // 1) key is the dataType + // 2) the catchall symbol "*" can be used + // 3) selection will start with transport dataType and THEN go to "*" if needed + transports: {}, - // Build temporary JSONP function - if ( s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url)) ) { - jsonp = s.jsonpCallback || ("jsonp" + jsc++); + // List of data converters + // 1) key format is "source_type destination_type" (a single space in-between) + // 2) the catchall symbol "*" can be used for source_type + converters: { - // Replace the =? sequence both in the query string and the data - if ( s.data ) { - s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1"); - } + // Convert anything to text + "* text": window.String, - s.url = s.url.replace(jsre, "=" + jsonp + "$1"); - - // We need to make sure - // that a JSONP style response is executed properly - s.dataType = "script"; - - // Handle JSONP-style loading - window[ jsonp ] = window[ jsonp ] || function(tmp){ - data = tmp; - success(); - complete(); - // Garbage collect - window[ jsonp ] = undefined; - try{ delete window[ jsonp ]; } catch(e){} - if ( head ) { - head.removeChild( script ); - } - }; - } + // Text to html (true = no transformation) + "text html": true, + + // Evaluate text as a json expression + "text json": jQuery.parseJSON, - if ( s.dataType === "script" && s.cache === null ) { - s.cache = false; + // Parse text as xml + "text xml": jQuery.parseXML } + }, - if ( s.cache === false && type === "GET" ) { - var ts = now(); + ajaxPrefilter: function( a , b ) { + ajaxPrefilterOrTransport( "prefilters" , a , b ); + }, - // try replacing _= if it is there - var ret = s.url.replace(rts, "$1_=" + ts + "$2"); + ajaxTransport: function( a , b ) { + return ajaxPrefilterOrTransport( "transports" , a , b ); + }, - // if nothing was replaced, add timestamp to the end - s.url = ret + ((ret === s.url) ? (rquery.test(s.url) ? "&" : "?") + "_=" + ts : ""); - } + // Main method + ajax: function( url , options ) { + + // If options is not an object, + // we simulate pre-1.5 signature + if ( typeof( options ) !== "object" ) { + options = url; + url = undefined; + } + + // Force options to be an object + options = options || {}; + + var // Create the final options object + s = jQuery.extend( true , {} , jQuery.ajaxSettings , options ), + // jQuery lists + jQuery_lastModified = jQuery.lastModified, + jQuery_etag = jQuery.etag, + // Callbacks contexts + // We force the original context if it exists + // or take it from jQuery.ajaxSettings otherwise + // (plain objects used as context get extended) + callbackContext = + ( s.context = ( "context" in options ? options : jQuery.ajaxSettings ).context ) || s, + globalEventContext = callbackContext === s ? jQuery.event : jQuery( callbackContext ), + // Deferreds + deferred = jQuery.Deferred(), + completeDeferred = jQuery._Deferred(), + // Status-dependent callbacks + statusCode = s.statusCode || {}, + // Headers (they are sent all at once) + requestHeaders = {}, + // Response headers + responseHeadersString, + responseHeaders, + // transport + transport, + // timeout handle + timeoutTimer, + // Cross-domain detection vars + loc = document.location, + protocol = loc.protocol || "http:", + parts, + // The jXHR state + state = 0, + // Loop variable + i, + // Fake xhr + jXHR = { + + readyState: 0, + + // Caches the header + setRequestHeader: function(name,value) { + if ( state === 0 ) { + requestHeaders[ name.toLowerCase() ] = value; + } + return this; + }, - // If data is available, append data to url for get requests - if ( s.data && type === "GET" ) { - s.url += (rquery.test(s.url) ? "&" : "?") + s.data; - } + // Raw string + getAllResponseHeaders: function() { + return state === 2 ? responseHeadersString : null; + }, - // Watch for a new set of requests - if ( s.global && ! jQuery.active++ ) { - jQuery.event.trigger( "ajaxStart" ); - } + // Builds headers hashtable if needed + getResponseHeader: function( key ) { - // Matches an absolute URL, and saves the domain - var parts = rurl.exec( s.url ), - remote = parts && (parts[1] && parts[1] !== location.protocol || parts[2] !== location.host); - - // If we're requesting a remote document - // and trying to load JSON or Script with a GET - if ( s.dataType === "script" && type === "GET" && remote ) { - var head = document.getElementsByTagName("head")[0] || document.documentElement; - var script = document.createElement("script"); - script.src = s.url; - if ( s.scriptCharset ) { - script.charset = s.scriptCharset; - } + var match; - // Handle Script loading - if ( !jsonp ) { - var done = false; - - // Attach handlers for all browsers - script.onload = script.onreadystatechange = function(){ - if ( !done && (!this.readyState || - this.readyState === "loaded" || this.readyState === "complete") ) { - done = true; - success(); - complete(); - - // Handle memory leak in IE - script.onload = script.onreadystatechange = null; - if ( head && script.parentNode ) { - head.removeChild( script ); + if ( state === 2 ) { + + if ( !responseHeaders ) { + + responseHeaders = {}; + + while( ( match = rheaders.exec( responseHeadersString ) ) ) { + responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ]; + } } + match = responseHeaders[ key.toLowerCase() ]; + } - }; - } - // Use insertBefore instead of appendChild to circumvent an IE6 bug. - // This arises when a base node is used (#2709 and #4378). - head.insertBefore( script, head.firstChild ); + return match || null; + }, - // We handle everything using the script element injection - return undefined; - } + // Cancel the request + abort: function( statusText ) { + if ( transport ) { + transport.abort( statusText || "abort" ); + } + done( 0 , statusText ); + return this; + } + }; - var requestDone = false; + // Callback for when everything is done + // It is defined here because jslint complains if it is declared + // at the end of the function (which would be more logical and readable) + function done( status , statusText , responses , headers) { - // Create the request object - var xhr = s.xhr(); + // Called once + if ( state === 2 ) { + return; + } - // Open the socket - // Passing null username, generates a login popup on Opera (#2865) - if ( s.username ) { - xhr.open(type, s.url, s.async, s.username, s.password); - } else { - xhr.open(type, s.url, s.async); - } + // State is "done" now + state = 2; + + // Dereference transport for early garbage collection + // (no matter how long the jXHR object will be used) + transport = undefined; - // Need an extra try/catch for cross domain requests in Firefox 3 - try { - // Set the correct header, if data is being sent - if ( s.data || origSettings && origSettings.contentType ) { - xhr.setRequestHeader("Content-Type", s.contentType); + // Set readyState + jXHR.readyState = status ? 4 : 0; + + // Cache response headers + responseHeadersString = headers || ""; + + // Clear timeout if it exists + if ( timeoutTimer ) { + clearTimeout(timeoutTimer); } - // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. - if ( s.ifModified ) { - if ( jQuery.lastModified[s.url] ) { - xhr.setRequestHeader("If-Modified-Since", jQuery.lastModified[s.url]); - } + var // Reference dataTypes and responseFields + dataTypes = s.dataTypes, + responseFields = s.responseFields, + responseField, + + // Flag to mark as success + isSuccess, + // Stored success + success, + // Stored error + error, + + // To keep track of statusCode based callbacks + oldStatusCode, + + // Actual response + response; + + // If we got responses: + // - find the right one + // - update dataTypes accordingly + // - set responseXXX accordingly too + if ( responses ) { + + var contents = s.contents, + transportDataType = dataTypes[0], + ct, + type, + finalDataType; + + // Auto (xml, json, script or text determined given headers) + if ( transportDataType === "*" && ( ct = jXHR.getResponseHeader( "content-type" ) ) ) { + + for ( type in contents ) { + if ( contents[ type ] && contents[ type ].test( ct ) ) { + transportDataType = dataTypes[0] = type; + break; + } + } - if ( jQuery.etag[s.url] ) { - xhr.setRequestHeader("If-None-Match", jQuery.etag[s.url]); + type = undefined; } - } - // Set header so the called script knows that it's an XMLHttpRequest - // Only send the header if it's not a remote XHR - if ( !remote ) { - xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest"); - } + // Get final dataType + for( type in responses ) { + if ( ! finalDataType && type === transportDataType ) { + finalDataType = type; + } + responseField = responseFields[ type ]; + if ( responseField && ! ( responseField in jXHR ) ) { + jXHR[ responseField ] = responses[ type ]; + } + } - // Set the Accepts header for the server, depending on the dataType - xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ? - s.accepts[ s.dataType ] + ", */*" : - s.accepts._default ); - } catch(e){} + // If no response with the expected dataType was provided + // Take the last response as a default if it exists + if ( ! finalDataType && type ) { + finalDataType = type; + if ( transportDataType === "*" ) { + dataTypes.shift(); + } + dataTypes.unshift( finalDataType ); + } - // Allow custom headers/mimetypes and early abort - if ( s.beforeSend && s.beforeSend.call(callbackContext, xhr, s) === false ) { - // Handle the global AJAX counter - if ( s.global && ! --jQuery.active ) { - jQuery.event.trigger( "ajaxStop" ); + // Get final response + response = responses[ finalDataType ]; } - // close opended socket - xhr.abort(); - return false; - } + // If successful, handle type chaining + if ( status >= 200 && status < 300 || status === 304 ) { - if ( s.global ) { - trigger("ajaxSend", [xhr, s]); - } + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. + if ( s.ifModified ) { + + var lastModified = jXHR.getResponseHeader("Last-Modified"), + etag = jXHR.getResponseHeader("Etag"); - // Wait for a response to come back - var onreadystatechange = function(isTimeout){ - // The request was aborted, clear the interval and decrement jQuery.active - if ( !xhr || xhr.readyState === 0 ) { - if ( ival ) { - // clear poll interval - clearInterval( ival ); - ival = null; - - // Handle the global AJAX counter - if ( s.global && ! --jQuery.active ) { - jQuery.event.trigger( "ajaxStop" ); + if (lastModified) { + jQuery_lastModified[ s.url ] = lastModified; + } + if (etag) { + jQuery_etag[ s.url ] = etag; } } - // The transfer is complete and the data is available, or the request timed out - } else if ( !requestDone && xhr && (xhr.readyState === 4 || isTimeout === "timeout") ) { - requestDone = true; + // If not modified + if ( status === 304 ) { - // clear poll interval - if (ival) { - clearInterval(ival); - ival = null; - } + statusText = "notmodified"; + isSuccess = 1; + + // If we have data + } else { - status = isTimeout === "timeout" ? - "timeout" : - !jQuery.httpSuccess( xhr ) ? - "error" : - s.ifModified && jQuery.httpNotModified( xhr, s.url ) ? - "notmodified" : - "success"; + statusText = "success"; - if ( status === "success" ) { - // Watch for, and catch, XML document parse errors + // Chain data conversions and determine the final value + // (if an exception is thrown in the process, it'll be notified as an error) try { - // process the data (runs the xml through httpData regardless of callback) - data = jQuery.httpData( xhr, s.dataType, s ); + + var i, + // Current dataType + current, + // Previous dataType + prev, + // Conversion expression + conversion, + // Conversion function + conv, + // Conversion functions (when text is used in-between) + conv1, + conv2, + // Local references to converters + converters = s.converters; + + // For each dataType in the chain + for( i = 0 ; i < dataTypes.length ; i++ ) { + + current = dataTypes[ i ]; + + // If a responseXXX field for this dataType exists + // and if it hasn't been set yet + responseField = responseFields[ current ]; + if ( responseField && ! ( responseField in jXHR ) ) { + jXHR[ responseField ] = response; + } + + // If this is not the first element + if ( i ) { + + // Get the dataType to convert from + prev = dataTypes[ i - 1 ]; + + // If no catch-all and dataTypes are actually different + if ( prev !== "*" && current !== "*" && prev !== current ) { + + // Get the converter + conversion = prev + " " + current; + conv = converters[ conversion ] || converters[ "* " + current ]; + + conv1 = conv2 = 0; + + // If there is no direct converter and none of the dataTypes is text + if ( ! conv && prev !== "text" && current !== "text" ) { + // Try with text in-between + conv1 = converters[ prev + " text" ] || converters[ "* text" ]; + conv2 = converters[ "text " + current ]; + // Revert back to a single converter + // if one of the converter is an equivalence + if ( conv1 === true ) { + conv = conv2; + } else if ( conv2 === true ) { + conv = conv1; + } + } + // If we found no converter, dispatch an error + if ( ! ( conv || conv1 && conv2 ) ) { + throw conversion; + } + // If found converter is not an equivalence + if ( conv !== true ) { + // Convert with 1 or 2 converters accordingly + response = conv ? conv( response ) : conv2( conv1( response ) ); + } + } + // If it is the first element of the chain + // and we have a dataFilter + } else if ( s.dataFilter ) { + // Apply the dataFilter + response = s.dataFilter( response , current ); + // Get dataTypes again in case the filter changed them + dataTypes = s.dataTypes; + } + } + // End of loop + + // We have a real success + success = response; + isSuccess = 1; + + // If an exception was thrown } catch(e) { - status = "parsererror"; - } - } - // Make sure that the request was successful or notmodified - if ( status === "success" || status === "notmodified" ) { - // JSONP handles its own success callback - if ( !jsonp ) { - success(); + // We have a parsererror + statusText = "parsererror"; + error = "" + e; + } - } else { - jQuery.handleError(s, xhr, status); } - // Fire the complete handlers - complete(); + // if not success, mark it as an error + } else { + error = statusText = statusText || "error"; + } + + // Set data for the fake xhr object + jXHR.status = status; + jXHR.statusText = statusText; - if ( isTimeout === "timeout" ) { - xhr.abort(); - } + // Success/Error + if ( isSuccess ) { + deferred.resolveWith( callbackContext , [ success , statusText , jXHR ] ); + } else { + deferred.rejectWith( callbackContext , [ jXHR , statusText , error ] ); + } - // Stop memory leaks - if ( s.async ) { - xhr = null; + // Status-dependent callbacks + oldStatusCode = statusCode; + statusCode = undefined; + jXHR.statusCode( oldStatusCode ); + + if ( s.global ) { + globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ) , + [ jXHR , s , isSuccess ? success : error ] ); + } + + // Complete + completeDeferred.resolveWith( callbackContext, [ jXHR , statusText ] ); + + if ( s.global ) { + globalEventContext.trigger( "ajaxComplete" , [ jXHR , s] ); + // Handle the global AJAX counter + if ( ! --jQuery.active ) { + jQuery.event.trigger( "ajaxStop" ); } } - }; + } - if ( s.async ) { - // don't attach the handler to the request, just poll it instead - var ival = setInterval(onreadystatechange, 13); + // Attach deferreds + deferred.promise( jXHR ); + jXHR.success = jXHR.done; + jXHR.error = jXHR.fail; + jXHR.complete = completeDeferred.done; - // Timeout checker - if ( s.timeout > 0 ) { - setTimeout(function(){ - // Check to see if the request is still happening - if ( xhr && !requestDone ) { - onreadystatechange( "timeout" ); + // Status-dependent callbacks + jXHR.statusCode = function( map ) { + if ( map ) { + var tmp; + if ( statusCode ) { + for( tmp in map ) { + statusCode[ tmp ] = [ statusCode[ tmp ] , map[ tmp ] ]; } - }, s.timeout); + } else { + tmp = map[ jXHR.status ]; + jXHR.done( tmp ).fail( tmp ); + } } + return this; + }; + + // Remove hash character (#7531: and string promotion) + // We also use the url parameter if available + s.url = ( "" + ( url || s.url ) ).replace( rhash , "" ); + + // Extract dataTypes list + s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( /\s+/ ); + + // Determine if a cross-domain request is in order + if ( ! s.crossDomain ) { + parts = rurl.exec( s.url.toLowerCase() ); + s.crossDomain = !!( + parts && + ( parts[ 1 ] && parts[ 1 ] != protocol || + parts[ 2 ] != loc.hostname || + ( parts[ 3 ] || ( ( parts[ 1 ] || protocol ) === "http:" ? 80 : 443 ) ) != + ( loc.port || ( protocol === "http:" ? 80 : 443 ) ) ) + ); } - // Send the data - try { - xhr.send( type === "POST" || type === "PUT" ? s.data : null ); - } catch(e) { - jQuery.handleError(s, xhr, null, e); - // Fire the complete handlers - complete(); + // Convert data if not already a string + if ( s.data && s.processData && typeof s.data !== "string" ) { + s.data = jQuery.param( s.data , s.traditional ); } - // firefox 1.5 doesn't fire statechange for sync requests - if ( !s.async ) { - onreadystatechange(); + // Apply prefilters + jQuery.ajaxPrefilter( s , options ); + + // Uppercase the type + s.type = s.type.toUpperCase(); + + // Determine if request has content + s.hasContent = ! rnoContent.test( s.type ); + + // Watch for a new set of requests + if ( s.global && jQuery.active++ === 0 ) { + jQuery.event.trigger( "ajaxStart" ); } - function success(){ - // If a local callback was specified, fire it and pass it the data - if ( s.success ) { - s.success.call( callbackContext, data, status, xhr ); + // More options handling for requests with no content + if ( ! s.hasContent ) { + + // If data is available, append data to url + if ( s.data ) { + s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data; } - // Fire the global callback - if ( s.global ) { - trigger( "ajaxSuccess", [xhr, s] ); + // Add anti-cache in url if needed + if ( s.cache === false ) { + + var ts = jQuery.now(), + // try replacing _= if it is there + ret = s.url.replace( rts , "$1_=" + ts ); + + // if nothing was replaced, add timestamp to the end + s.url = ret + ( (ret == s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : ""); } } - function complete(){ - // Process result - if ( s.complete ) { - s.complete.call( callbackContext, xhr, status); - } + // Set the correct header, if data is being sent + if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { + requestHeaders[ "content-type" ] = s.contentType; + } - // The request was completed - if ( s.global ) { - trigger( "ajaxComplete", [xhr, s] ); + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. + if ( s.ifModified ) { + if ( jQuery_lastModified[ s.url ] ) { + requestHeaders[ "if-modified-since" ] = jQuery_lastModified[ s.url ]; } - - // Handle the global AJAX counter - if ( s.global && ! --jQuery.active ) { - jQuery.event.trigger( "ajaxStop" ); + if ( jQuery_etag[ s.url ] ) { + requestHeaders[ "if-none-match" ] = jQuery_etag[ s.url ]; } } - - function trigger(type, args){ - (s.context ? jQuery(s.context) : jQuery.event).trigger(type, args); - } - // return XMLHttpRequest to allow aborting the request etc. - return xhr; - }, + // Set the Accepts header for the server, depending on the dataType + requestHeaders.accept = s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? + s.accepts[ s.dataTypes[ 0 ] ] + ( s.dataTypes[ 0 ] !== "*" ? ", */*; q=0.01" : "" ) : + s.accepts[ "*" ]; - handleError: function( s, xhr, status, e ) { - // If a local callback was specified, fire it - if ( s.error ) { - s.error.call( s.context || window, xhr, status, e ); + // Check for headers option + for ( i in s.headers ) { + requestHeaders[ i.toLowerCase() ] = s.headers[ i ]; } - // Fire the global callback - if ( s.global ) { - (s.context ? jQuery(s.context) : jQuery.event).trigger( "ajaxError", [xhr, s, e] ); - } - }, + // Allow custom headers/mimetypes and early abort + if ( s.beforeSend && ( s.beforeSend.call( callbackContext , jXHR , s ) === false || state === 2 ) ) { - // Counter for holding the number of active queries - active: 0, + // Abort if not done already + done( 0 , "abort" ); - // Determines if an XMLHttpRequest was successful or not - httpSuccess: function( xhr ) { - try { - // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450 - return !xhr.status && location.protocol === "file:" || - // Opera returns 0 when status is 304 - ( xhr.status >= 200 && xhr.status < 300 ) || - xhr.status === 304 || xhr.status === 1223 || xhr.status === 0; - } catch(e){} - - return false; - }, + // Return false + jXHR = false; + + } else { - // Determines if an XMLHttpRequest returns NotModified - httpNotModified: function( xhr, url ) { - var lastModified = xhr.getResponseHeader("Last-Modified"), - etag = xhr.getResponseHeader("Etag"); + // Install callbacks on deferreds + for ( i in { success:1, error:1, complete:1 } ) { + jXHR[ i ]( s[ i ] ); + } - if ( lastModified ) { - jQuery.lastModified[url] = lastModified; - } + // Get transport + transport = jQuery.ajaxTransport( s , options ); - if ( etag ) { - jQuery.etag[url] = etag; - } + // If no transport, we auto-abort + if ( ! transport ) { - // Opera returns 0 when status is 304 - return xhr.status === 304 || xhr.status === 0; - }, + done( 0 , "notransport" ); - httpData: function( xhr, type, s ) { - var ct = xhr.getResponseHeader("content-type"), - xml = type === "xml" || !type && ct && ct.indexOf("xml") >= 0, - data = xml ? xhr.responseXML : xhr.responseText; + } else { - if ( xml && data.documentElement.nodeName === "parsererror" ) { - throw "parsererror"; - } + // Set state as sending + state = jXHR.readyState = 1; - // Allow a pre-filtering function to sanitize the response - // s is checked to keep backwards compatibility - if ( s && s.dataFilter ) { - data = s.dataFilter( data, type ); - } + // Send global event + if ( s.global ) { + globalEventContext.trigger( "ajaxSend" , [ jXHR , s ] ); + } - // The filter can actually parse the response - if ( typeof data === "string" ) { + // Timeout + if ( s.async && s.timeout > 0 ) { + timeoutTimer = setTimeout(function(){ + jXHR.abort( "timeout" ); + }, s.timeout); + } - // If the type is "script", eval it in global context - if ( type === "script" ) { - jQuery.globalEval( data ); - } + // Try to send + try { + transport.send(requestHeaders, done); + } catch (e) { + // Propagate exception as error if not done + if ( status === 1 ) { - // Get the JavaScript object, if JSON is used. - if ( type === "json" ) { - if ( typeof JSON === "object" && JSON.parse ) { - data = JSON.parse( data ); - } else { - data = (new Function("return " + data))(); + done(0, "error", "" + e); + jXHR = false; + + // Simply rethrow otherwise + } else { + jQuery.error(e); + } } } } - return data; + return jXHR; }, // Serialize an array of form elements or a set of // key/values into a query string - param: function( a ) { + param: function( a, traditional ) { var s = [], - param_traditional = jQuery.param.traditional; - - function add( key, value ){ - // If value is a function, invoke it and return its value - value = jQuery.isFunction(value) ? value() : value; - s[ s.length ] = encodeURIComponent(key) + '=' + encodeURIComponent(value); + add = function( key, value ) { + // If value is a function, invoke it and return its value + value = jQuery.isFunction(value) ? value() : value; + s[ s.length ] = encodeURIComponent(key) + "=" + encodeURIComponent(value); + }; + + // Set traditional to true for jQuery <= 1.3.2 behavior. + if ( traditional === undefined ) { + traditional = jQuery.ajaxSettings.traditional; } - - // If an array was passed in, assume that it is an array - // of form elements + + // If an array was passed in, assume that it is an array of form elements. if ( jQuery.isArray(a) || a.jquery ) { // Serialize the form elements jQuery.each( a, function() { add( this.name, this.value ); }); - + } else { - // Encode parameters from object, recursively. If - // jQuery.param.traditional is set, encode the "old" way - // (the way 1.3.2 or older did it) - jQuery.each( a, function buildParams( prefix, obj ) { - - if ( jQuery.isArray(obj) ) { - jQuery.each( obj, function(i,v){ - // Due to rails' limited request param syntax, numeric array - // indices are not supported. To avoid serialization ambiguity - // issues, serialized arrays can only contain scalar values. php - // does not have this issue, but we should go with the lowest - // common denominator - add( prefix + ( param_traditional ? "" : "[]" ), v ); - }); - - } else if ( typeof obj == "object" ) { - if ( param_traditional ) { - add( prefix, obj ); - - } else { - jQuery.each( obj, function(k,v){ - buildParams( prefix ? prefix + "[" + k + "]" : k, v ); - }); - } - } else { - add( prefix, obj ); - } - }); + // If traditional, encode the "old" way (the way 1.3.2 or older + // did it), otherwise encode params recursively. + for ( var prefix in a ) { + buildParams( prefix, a[prefix], traditional, add ); + } } + // Return the resulting serialization return s.join("&").replace(r20, "+"); } +}); + +function buildParams( prefix, obj, traditional, add ) { + if ( jQuery.isArray(obj) && obj.length ) { + // Serialize array item. + jQuery.each( obj, function( i, v ) { + if ( traditional || rbracket.test( prefix ) ) { + // Treat each array item as a scalar. + add( prefix, v ); + + } else { + // If array item is non-scalar (array or object), encode its + // numeric index to resolve deserialization ambiguity issues. + // Note that rack (as of 1.0.0) can't currently deserialize + // nested arrays properly, and attempting to do so may cause + // a server error. Possible fixes are to modify rack's + // deserialization algorithm or to provide an option or flag + // to force array serialization to be shallow. + buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add ); + } + }); + + } else if ( !traditional && obj != null && typeof obj === "object" ) { + // If we see an array here, it is empty and should be treated as an empty + // object + if ( jQuery.isArray( obj ) || jQuery.isEmptyObject( obj ) ) { + add( prefix, "" ); + + // Serialize object item. + } else { + jQuery.each( obj, function( k, v ) { + buildParams( prefix + "[" + k + "]", v, traditional, add ); + }); + } + + } else { + // Serialize scalar item. + add( prefix, obj ); + } +} + +// This is still on the jQuery object... for now +// Want to move this to jQuery.ajax some day +jQuery.extend({ + + // Counter for holding the number of active queries + active: 0, + + // Last-Modified header cache for next request + lastModified: {}, + etag: {} }); + +// Base function for both ajaxPrefilter and ajaxTransport +function ajaxPrefilterOrTransport( arg0 , arg1 , arg2 ) { + + var type = jQuery.type( arg1 ), + structure = jQuery.ajaxSettings[ arg0 ], + i, + length; + + // We have an options map so we have to inspect the structure + if ( type === "object" ) { + + var options = arg1, + originalOptions = arg2, + // When dealing with prefilters, we execute only + // (no selection so we never stop when a function + // returns a non-falsy, non-string value) + executeOnly = ( arg0 === "prefilters" ), + inspect = function( dataType, tested ) { + + if ( ! tested[ dataType ] ) { + + tested[ dataType ] = true; + + var list = structure[ dataType ], + selected; + + for( i = 0, length = list ? list.length : 0 ; ( executeOnly || ! selected ) && i < length ; i++ ) { + selected = list[ i ]( options , originalOptions ); + // If we got redirected to a different dataType, + // we add it and switch to the corresponding list + if ( typeof( selected ) === "string" && selected !== dataType ) { + options.dataTypes.unshift( selected ); + selected = inspect( selected , tested ); + // We always break in order not to continue + // to iterate in previous list + break; + } + } + // If we're only executing or nothing was selected + // we try the catchall dataType + if ( executeOnly || ! selected ) { + selected = inspect( "*" , tested ); + } + // This will be ignored by ajaxPrefilter + // so it's safe to return no matter what + return selected; + } + + }; + + // Start inspection with current transport dataType + return inspect( options.dataTypes[ 0 ] , {} ); + + } else { + + // We're requested to add to the structure + // Signature is ( dataTypeExpression , function ) + // with dataTypeExpression being optional and + // defaulting to catchAll (*) + type = type === "function"; + + if ( type ) { + arg2 = arg1; + arg1 = undefined; + } + arg1 = arg1 || "*"; + + // We control that the second argument is really a function + if ( type || jQuery.isFunction( arg2 ) ) { + + var dataTypes = arg1.split( /\s+/ ), + functor = arg2, + dataType, + list, + placeBefore; + + // For each dataType in the dataTypeExpression + for( i = 0 , length = dataTypes.length ; i < length ; i++ ) { + dataType = dataTypes[ i ]; + // We control if we're asked to add before + // any existing element + placeBefore = /^\+/.test( dataType ); + if ( placeBefore ) { + dataType = dataType.substr( 1 ); + } + list = structure[ dataType ] = structure[ dataType ] || []; + // then we add to the structure accordingly + list[ placeBefore ? "unshift" : "push" ]( functor ); + } + } + } +} + +})( jQuery );