scratch – Diff between revs 58 and 125

Subversion Repositories:

?pathlinks?

Rev 58 – Details – Blame – Last modification – View Log

-define( [
+define([
 	"./core",
-	"./var/document",
-	"./var/rnothtmlwhite",
+	"./var/rnotwhite",
-	"./ajax/var/location",
 	"./ajax/var/nonce",
 	"./ajax/var/rquery",
 	"./core/init",
+	"./ajax/parseJSON",
 	"./ajax/parseXML",
-	"./event/trigger",
-	"./deferred",
+	"./deferred"
-	"./serialize" // jQuery.param
-], function( jQuery, document, rnothtmlwhite, location, nonce, rquery ) {
+], function( jQuery, rnotwhite, nonce, rquery ) {
-"use strict";
-var
-	r20 = /%20/g,
+var
 	rhash = /#.*$/,
-	rantiCache = /([?&])_=[^&]*/,
+	rts = /([?&])_=[^&]*/,
-	rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
 	rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
 	// #7653, #8125, #8152: local protocol detection
 	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
 	rnoContent = /^(?:GET|HEAD)$/,
+	rprotocol = /^\/\//,
-	rprotocol = /^\/\//,
+	rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,
 	/* Prefilters
 	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
 	transports = {},
 	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
+	allTypes = "*/".concat( "*" ),
-	allTypes = "*/".concat( "*" ),
+	// Document location
+	ajaxLocation = window.location.href,
-	// Anchor tag for parsing the document origin
-	originAnchor = document.createElement( "a" );
+	// Segment location into parts
-	originAnchor.href = location.href;
+	ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
 			dataTypeExpression = "*";
+		}
 		var dataType,
 			i = 0,
-			dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
+			dataTypes = dataTypeExpression.toLowerCase().match( rnotwhite ) || [];
 		if ( jQuery.isFunction( func ) ) {
 		if ( jQuery.isFunction( func ) ) {
-			// For each dataType in the dataTypeExpression
-			while ( ( dataType = dataTypes[ i++ ] ) ) {
+			// For each dataType in the dataTypeExpression
 			while ( (dataType = dataTypes[i++]) ) {
 				// Prepend if requested
-				if ( dataType[ 0 ] === "+" ) {
+				if ( dataType[0] === "+" ) {
 	function inspect( dataType ) {
 		var selected;
 		inspected[ dataType ] = true;
 		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
 			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
-			if ( typeof dataTypeOrTransport === "string" &&
-				!seekingTransport && !inspected[ dataTypeOrTransport ] ) {
+			if ( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
 				options.dataTypes.unshift( dataTypeOrTransport );
 				inspect( dataTypeOrTransport );
 				return false;
 			} else if ( seekingTransport ) {
 				return !( selected = dataTypeOrTransport );
 	// Check to see if we have a response for the expected dataType
 	if ( dataTypes[ 0 ] in responses ) {
 		finalDataType = dataTypes[ 0 ];
-	} else {
 	} else {
 		// Try convertible dataTypes
 		for ( type in responses ) {
-			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
+			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
 				finalDataType = type;
 				break;
+			}
 			if ( !firstDataType ) {
 				firstDataType = type;
+			}
-		}
+		}
 		// Or just use first one
 		finalDataType = finalDataType || firstDataType;
+	}
  * Also sets the responseXXX fields on the jqXHR instance
  */
 function ajaxConvert( s, response, jqXHR, isSuccess ) {
 	var conv2, current, conv, tmp, prev,
 		converters = {},
 		// Work with a copy of dataTypes in case we need to modify it for conversion
 		dataTypes = s.dataTypes.slice();
 	// Create converters map with lowercased keys
 							// If prev can be converted to accepted input
 							conv = converters[ prev + " " + tmp[ 0 ] ] ||
 								converters[ "* " + tmp[ 0 ] ];
-							if ( conv ) {
 							if ( conv ) {
 								// Condense equivalence converters
 								if ( conv === true ) {
 									conv = converters[ conv2 ];
 				// Apply converter (if not an equivalence)
 				if ( conv !== true ) {
 					// Unless errors are allowed to bubble, catch and return them
-					if ( conv && s.throws ) {
+					if ( conv && s[ "throws" ] ) {
 						response = conv( response );
 					} else {
 						try {
-							response = conv( response );
-						} catch ( e ) {
-							return {
+							response = conv( response );
-								state: "parsererror",
-								error: conv ? e : "No conversion from " + prev + " to " + current
+						} catch ( e ) {
-							};
+							return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current };
+						}
+					}
+				}
 	// Last-Modified header cache for next request
 	lastModified: {},
 	etag: {},
 	ajaxSettings: {
-		url: location.href,
+		url: ajaxLocation,
 		type: "GET",
-		isLocal: rlocalProtocol.test( location.protocol ),
+		isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
 		global: true,
 		processData: true,
 		async: true,
-		contentType: "application/x-www-form-urlencoded; charset=UTF-8",
 		contentType: "application/x-www-form-urlencoded; charset=UTF-8",
 		/*
 		timeout: 0,
 		data: null,
 		dataType: null,
 			xml: "application/xml, text/xml",
 			json: "application/json, text/javascript"
 		},
 		contents: {
-			xml: /\bxml\b/,
+			xml: /xml/,
-			html: /\bhtml/,
+			html: /html/,
-			json: /\bjson\b/
+			json: /json/
 		},
 		responseFields: {
 			// Text to html (true = no transformation)
 			"text html": true,
 			// Evaluate text as a json expression
-			"text json": JSON.parse,
+			"text json": jQuery.parseJSON,
 		// Force options to be an object
 		options = options || {};
 		var transport,
 		var transport,
-			// URL without anti-cache param
-			cacheURL,
+			// URL without anti-cache param
 			cacheURL,
 			// Response headers
-			responseHeadersString,
-			responseHeaders,
+			responseHeadersString,
 			responseHeaders,
-			// timeout handle
-			timeoutTimer,
+			// timeout handle
-			// Url cleanup var
-			urlAnchor,
+			timeoutTimer,
-			// Request state (becomes false upon send and true upon completion)
-			completed,
+			// Cross-domain detection vars
 			parts,
-			// To know if global events are to be dispatched
-			fireGlobals,
+			// To know if global events are to be dispatched
 			fireGlobals,
-			// Loop variable
-			i,
-			// uncached part of the url
-			uncached,
+			// Loop variable
 			i,
-			// Create the final options object
-			s = jQuery.ajaxSetup( {}, options ),
+			// Create the final options object
 			s = jQuery.ajaxSetup( {}, options ),
-			// Callbacks context
-			callbackContext = s.context || s,
+			// Callbacks context
-			// Context for global events is callbackContext if it is a DOM node or jQuery collection
+			callbackContext = s.context || s,
-			globalEventContext = s.context &&
+			// Context for global events is callbackContext if it is a DOM node or jQuery collection
-				( callbackContext.nodeType || callbackContext.jquery ) ?
+			globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ?
-					jQuery( callbackContext ) :
-					jQuery.event,
+				jQuery( callbackContext ) :
 				jQuery.event,
 			// Deferreds
-			deferred = jQuery.Deferred(),
-			completeDeferred = jQuery.Callbacks( "once memory" ),
+			deferred = jQuery.Deferred(),
 			completeDeferred = jQuery.Callbacks("once memory"),
-			// Status-dependent callbacks
-			statusCode = s.statusCode || {},
+			// Status-dependent callbacks
 			statusCode = s.statusCode || {},
 			// Headers (they are sent all at once)
+			requestHeaders = {},
-			requestHeaders = {},
+			requestHeadersNames = {},
-			requestHeadersNames = {},
+			// The jqXHR state
 			state = 0,
-			// Default abort message
-			strAbort = "canceled",
+			// Default abort message
 			strAbort = "canceled",
 			// Fake xhr
 			jqXHR = {
 				readyState: 0,
 				// Builds headers hashtable if needed
 				getResponseHeader: function( key ) {
 					var match;
-					if ( completed ) {
+					if ( state === 2 ) {
 						if ( !responseHeaders ) {
 							responseHeaders = {};
 					return match == null ? null : match;
 				},
 				// Raw string
 				getAllResponseHeaders: function() {
-					return completed ? responseHeadersString : null;
+					return state === 2 ? responseHeadersString : null;
 				},
 				// Caches the header
 				setRequestHeader: function( name, value ) {
-					if ( completed == null ) {
+					var lname = name.toLowerCase();
-						name = requestHeadersNames[ name.toLowerCase() ] =
+					if ( !state ) {
-							requestHeadersNames[ name.toLowerCase() ] || name;
+						name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
 						requestHeaders[ name ] = value;
+					}
 					return this;
 				},
 				// Overrides response content-type header
 				overrideMimeType: function( type ) {
-					if ( completed == null ) {
+					if ( !state ) {
 						s.mimeType = type;
+					}
 					return this;
 				},
 				// Status-dependent callbacks
-				statusCode: function( map ) {
-					var code;
-					if ( map ) {
-						if ( completed ) {
-							// Execute the appropriate callbacks
-							jqXHR.always( map[ jqXHR.status ] );
+				statusCode: function( map ) {
+					var code;
-						} else {
+					if ( map ) {
 						if ( state < 2 ) {
+							for ( code in map ) {
+								// Lazy-add the new callback in a way that preserves old ones
+								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
 							// Lazy-add the new callbacks in a way that preserves old ones
-							for ( code in map ) {
+						} else {
-								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
+							// Execute the appropriate callbacks
 							jqXHR.always( map[ jqXHR.status ] );
 					return this;
+				}
 			};
+		// Attach deferreds
+		deferred.promise( jqXHR ).complete = completeDeferred.add;
-		// Attach deferreds
+		jqXHR.success = jqXHR.done;
+		jqXHR.error = jqXHR.fail;
 		deferred.promise( jqXHR );
 		// Remove hash character (#7531: and string promotion)
 		// Add protocol if not provided (prefilters might expect it)
 		// Handle falsy url in the settings object (#10093: consistency with old signature)
 		// We also use the url parameter if available
-		s.url = ( ( url || s.url || location.href ) + "" )
+		s.url = ( ( url || s.url || ajaxLocation ) + "" ).replace( rhash, "" )
-			.replace( rprotocol, location.protocol + "//" );
+			.replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
 		// Alias method option to type as per ticket #12004
 		s.type = options.method || options.type || s.method || s.type;
 		// Extract dataTypes list
-		s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
-		// A cross-domain request is in order when the origin doesn't match the current origin.
-		if ( s.crossDomain == null ) {
-			urlAnchor = document.createElement( "a" );
-			// Support: IE <=8 - 11, Edge 12 - 13
-			// IE throws exception on accessing the href property if url is malformed,
+		s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( rnotwhite ) || [ "" ];
-			// e.g. http://example.com:80x/
-			try {
-				urlAnchor.href = s.url;
+		// A cross-domain request is in order when we have a protocol:host:port mismatch
-				// Support: IE <=8 - 11 only
-				// Anchor's host property isn't correctly set when s.url is relative
-				urlAnchor.href = urlAnchor.href;
+		if ( s.crossDomain == null ) {
-				s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
-					urlAnchor.protocol + "//" + urlAnchor.host;
-			} catch ( e ) {
+			parts = rurl.exec( s.url.toLowerCase() );
 			s.crossDomain = !!( parts &&
-				// If there is an error parsing the URL, assume it is crossDomain,
+				( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
-				// it can be rejected by the transport if it is invalid
+					( parts[ 3 ] || ( parts[ 1 ] === "http:" ? "80" : "443" ) ) !==
-				s.crossDomain = true;
+						( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? "80" : "443" ) ) )
 		// Apply prefilters
 		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
 		// If request was aborted inside a prefilter, stop there
-		if ( completed ) {
+		if ( state === 2 ) {
 			return jqXHR;
+		}
 		// Determine if request has content
 		s.hasContent = !rnoContent.test( s.type );
 		// Save the URL in case we're toying with the If-Modified-Since
-		// and/or If-None-Match header later on
-		// Remove hash to simplify url manipulation
+		// and/or If-None-Match header later on
-		cacheURL = s.url.replace( rhash, "" );
+		cacheURL = s.url;
-		// More options handling for requests with no content
-		if ( !s.hasContent ) {
-			// Remember the hash so we can put it back
+		// More options handling for requests with no content
-			uncached = s.url.slice( cacheURL.length );
+		if ( !s.hasContent ) {
-			// If data is available, append data to url
-			if ( s.data ) {
+			// If data is available, append data to url
-				cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
+			if ( s.data ) {
 				cacheURL = ( s.url += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data );
 				// #9682: remove data so that it's not used in an eventual retry
 				delete s.data;
 			}
-			// Add or update anti-cache param if needed
-			if ( s.cache === false ) {
-				cacheURL = cacheURL.replace( rantiCache, "$1" );
+			// Add anti-cache in url if needed
-				uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
-			}
+			if ( s.cache === false ) {
+				s.url = rts.test( cacheURL ) ?
-			// Put hash and anti-cache on the URL that will be requested (gh-1732)
-			s.url = cacheURL + uncached;
+					// If there is already a '_' parameter, set its value
 					cacheURL.replace( rts, "$1_=" + nonce++ ) :
 		// Change '%20' to '+' if this is encoded form body content (gh-2658)
-		} else if ( s.data && s.processData &&
+					// Otherwise add one to the end
 		// Set the Accepts header for the server, depending on the dataType
 		jqXHR.setRequestHeader(
 			"Accept",
-			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
-				s.accepts[ s.dataTypes[ 0 ] ] +
+			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
-					( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
+				s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
 				s.accepts[ "*" ]
 		);
 		// Check for headers option
 		for ( i in s.headers ) {
 			jqXHR.setRequestHeader( i, s.headers[ i ] );
-		}
+		}
-		// Allow custom headers/mimetypes and early abort
 		if ( s.beforeSend &&
-			( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
+		// Allow custom headers/mimetypes and early abort
 		if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
 			// Abort if not done already and return
 			return jqXHR.abort();
+		}
 		// Aborting is no longer a cancellation
 		strAbort = "abort";
 		// Install callbacks on deferreds
-		completeDeferred.add( s.complete );
+		for ( i in { success: 1, error: 1, complete: 1 } ) {
 			// Send global event
 			if ( fireGlobals ) {
 				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
-			}
-			// If request was aborted inside ajaxSend, stop there
-			if ( completed ) {
-				return jqXHR;
-			}
+			}
 			// Timeout
 			if ( s.async && s.timeout > 0 ) {
-				timeoutTimer = window.setTimeout( function() {
+				timeoutTimer = setTimeout(function() {
-					jqXHR.abort( "timeout" );
+					jqXHR.abort("timeout");
 				}, s.timeout );
+			}
 			try {
-				completed = false;
+				state = 1;
-				transport.send( requestHeaders, done );
-			} catch ( e ) {
+				transport.send( requestHeaders, done );
+			} catch ( e ) {
+				// Propagate exception as error if not done
+				if ( state < 2 ) {
+					done( -1, e );
-				// Rethrow post-completion exceptions
+				// Simply rethrow otherwise
-				if ( completed ) {
+				} else {
-					throw e;
-				}
-				// Propagate others as results
+					throw e;
 				done( -1, e );
+			}
+		}
 		// Callback for when everything is done
 		function done( status, nativeStatusText, responses, headers ) {
 			var isSuccess, success, error, response, modified,
 				statusText = nativeStatusText;
+			// Called once
-			// Ignore repeat invocations
+			if ( state === 2 ) {
-			if ( completed ) {
+				return;
 				return;
-			}
 			// State is "done" now
-			completed = true;
+			state = 2;
 			// Clear timeout if it exists
 					success = response.data;
 					error = response.error;
 					isSuccess = !error;
+				}
 			} else {
 				// Extract error from statusText and normalize for non-aborts
 				error = statusText;
 				if ( status || !statusText ) {
 					statusText = "error";
 					if ( status < 0 ) {
 			// Complete
 			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
 			if ( fireGlobals ) {
-				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
 				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
 				// Handle the global AJAX counter
 				if ( !( --jQuery.active ) ) {
-					jQuery.event.trigger( "ajaxStop" );
+					jQuery.event.trigger("ajaxStop");
+				}
+	}
-} );
+});
 jQuery.each( [ "get", "post" ], function( i, method ) {
-	jQuery[ method ] = function( url, data, callback, type ) {
 	jQuery[ method ] = function( url, data, callback, type ) {
 		// Shift arguments if data argument was omitted
 		if ( jQuery.isFunction( data ) ) {
 			type = type || callback;
 			callback = data;
 			data = undefined;
-		}
+		}
 		// The url can be an options object (which then must have .url)
-		return jQuery.ajax( jQuery.extend( {
+		return jQuery.ajax({
 			url: url,
 			type: method,
 			dataType: type,
 			data: data,
 			success: callback
-		}, jQuery.isPlainObject( url ) && url ) );
+		});
 	};
-} );
+});