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] === "+" ) {
 					dataType = dataType.slice( 1 ) || "*";
-					( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
+					(structure[ dataType ] = structure[ dataType ] || []).unshift( func );
 				// Otherwise append
 				} else {
-					( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
+					(structure[ dataType ] = structure[ dataType ] || []).push( func );
+				}
+			}
 	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 );
+			}
-		} );
+		});
 		return selected;
+	}
 	return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
 	var key, deep,
 		flatOptions = jQuery.ajaxSettings.flatOptions || {};
 	for ( key in src ) {
 		if ( src[ key ] !== undefined ) {
-			( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
+			( flatOptions[ key ] ? target : ( deep || (deep = {}) ) )[ key ] = src[ key ];
+		}
+	}
 	if ( deep ) {
 		jQuery.extend( true, target, deep );
 	// Remove auto dataType and get content-type in the process
 	while ( dataTypes[ 0 ] === "*" ) {
 		dataTypes.shift();
 		if ( ct === undefined ) {
-			ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
+			ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
+		}
+	}
 	// 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
 		prev = current;
 		current = dataTypes.shift();
 		if ( current ) {
-			// There's only work to do if current dataType is non-auto
+		// There's only work to do if current dataType is non-auto
 			if ( current === "*" ) {
 							// 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 };
+						}
+					}
+				}
+			}
+		}
+	}
 	return { state: "success", data: response };
+}
-jQuery.extend( {
+jQuery.extend({
 	// Counter for holding the number of active queries
 	active: 0,
 	// Last-Modified header cache for next request
 	lastModified: {},
 	etag: {},
 	ajaxSettings: {
-		url: location.href,
-		type: "GET",
+		url: ajaxLocation,
-		isLocal: rlocalProtocol.test( location.protocol ),
+		type: "GET",
-		global: true,
+		isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
-		processData: true,
+		global: true,
-		async: true,
+		processData: true,
 			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 = {};
-							while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
+							while ( (match = rheaders.exec( responseHeadersString )) ) {
-								responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
+								responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
+							}
+						}
 						match = responseHeaders[ key.toLowerCase() ];
+					}
 					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 ) {
+				},
 				// Status-dependent callbacks
-							// Execute the appropriate callbacks
+				statusCode: function( map ) {
+					var code;
+					if ( map ) {
+						if ( state < 2 ) {
-							jqXHR.always( map[ jqXHR.status ] );
+							for ( code in map ) {
-						} else {
+								// 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
 					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;
+		}
 		// We can fire global events as of now if asked to
 		// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
 		fireGlobals = jQuery.event && s.global;
 		// Watch for a new set of requests
 		if ( fireGlobals && jQuery.active++ === 0 ) {
-			jQuery.event.trigger( "ajaxStart" );
+			jQuery.event.trigger("ajaxStart");
+		}
 		// Uppercase the type
-		s.type = s.type.toUpperCase();
+		s.type = s.type.toUpperCase();
 		// Determine if request has content
-		s.hasContent = !rnoContent.test( s.type );
+		// Determine if request has content
-		// 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
+		s.hasContent = !rnoContent.test( s.type );
 		cacheURL = s.url.replace( rhash, "" );
+		// Save the URL in case we're toying with the If-Modified-Since
-		// More options handling for requests with no content
-		if ( !s.hasContent ) {
+		// and/or If-None-Match header later on
 		cacheURL = s.url;
 			// Remember the hash so we can put it back
-			uncached = s.url.slice( cacheURL.length );
+		// More options handling for requests with no content
 		if ( !s.hasContent ) {
-			// If data is available, append data to url
-			if ( s.data ) {
-				cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
+			// If data is available, append data to url
-				// #9682: remove data so that it's not used in an eventual retry
+			if ( s.data ) {
-				delete s.data;
-			}
+				cacheURL = ( s.url += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data );
+				// #9682: remove data so that it's not used in an eventual retry
-			// Add or update anti-cache param if needed
+				delete s.data;
 			if ( s.cache === false ) {
 				cacheURL = cacheURL.replace( rantiCache, "$1" );
-				uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
+			// Add anti-cache in url if needed
 			if ( s.cache === false ) {
+		}
 		// 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
 			// If successful, handle type chaining
 			if ( isSuccess ) {
 				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
 				if ( s.ifModified ) {
-					modified = jqXHR.getResponseHeader( "Last-Modified" );
+					modified = jqXHR.getResponseHeader("Last-Modified");
 					if ( modified ) {
 						jQuery.lastModified[ cacheURL ] = modified;
 					}
-					modified = jqXHR.getResponseHeader( "etag" );
+					modified = jqXHR.getResponseHeader("etag");
 					if ( modified ) {
 						jQuery.etag[ cacheURL ] = modified;
+					}
 					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");
+				}
+			}
+		}
 	},
 	getScript: function( url, callback ) {
 		return jQuery.get( url, undefined, callback, "script" );
 	}
-} );
+});
-jQuery.each( [ "get", "post" ], function( i, method ) {
-	jQuery[ method ] = 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 omitted
 		if ( jQuery.isFunction( data ) ) {
 			type = type || callback;
 			callback = data;
-			data = undefined;
-		}
+			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 ) );
+		});
 	};