Added deferred to core. Used internally for DOM readyness and ajax ca…

…llbacks.

src/core.js

@@ -60,8 +60,8 @@ var jQuery = function( selector, context ) {
 	// Has the ready events already been bound?
 	readyBound = false,
 
-	// The functions to execute on DOM ready
-	readyList = [],
+	// The deferred used on DOM ready
+	readyList,
 
 	// The ready event handler
 	DOMContentLoaded,
@@ -75,7 +75,10 @@ var jQuery = function( selector, context ) {
 	indexOf = Array.prototype.indexOf,
 
 	// [[Class]] -> type pairs
-	class2type = {};
+	class2type = {},
+
+	// Marker for deferred
+	deferredMarker = [];
 
 jQuery.fn = jQuery.prototype = {
 	init: function( selector, context ) {
@@ -253,22 +256,12 @@ jQuery.fn = jQuery.prototype = {
 		return jQuery.each( this, callback, args );
 	},
 
-	ready: function( fn ) {
+	ready: function() {
 		// Attach the listeners
 		jQuery.bindReady();
-
-		// If the DOM is already ready
-		if ( jQuery.isReady ) {
-			// Execute the function immediately
-			fn.call( document, jQuery );
-
-		// Otherwise, remember the function for later
-		} else if ( readyList ) {
-			// Add the function to the wait list
-			readyList.push( fn );
-		}
-
-		return this;
+
+		// Change ready & apply
+		return ( jQuery.fn.ready = readyList.then ).apply( this , arguments );
 	},
 
 	eq: function( i ) {
@@ -415,23 +408,11 @@ jQuery.extend({
 			}
 
 			// If there are functions bound, to execute
-			if ( readyList ) {
-				// Execute all of them
-				var fn,
-					i = 0,
-					ready = readyList;
-
-				// Reset the list of functions
-				readyList = null;
-
-				while ( (fn = ready[ i++ ]) ) {
-					fn.call( document, jQuery );
-				}
-
-				// Trigger any bound ready events
-				if ( jQuery.fn.trigger ) {
-					jQuery( document ).trigger( "ready" ).unbind( "ready" );
-				}
+			readyList.fire( document , [ jQuery ] );
+
+			// Trigger any bound ready events
+			if ( jQuery.fn.trigger ) {
+				jQuery( document ).trigger( "ready" ).unbind( "ready" );
 			}
 		}
 	},
@@ -800,6 +781,160 @@ jQuery.extend({
 	now: function() {
 		return (new Date()).getTime();
 	},
+
+	// Create a simple deferred (one callbacks list)
+	_deferred: function( cancellable ) {
+
+		// cancellable by default
+		cancellable = cancellable !== false;
+
+		var // callbacks list
+			callbacks = [],
+			// stored [ context , args ]
+			fired,
+			// to avoid firing when already doing so
+			firing,
+			// flag to know if the deferred has been cancelled
+			cancelled,
+			// the deferred itself
+			deferred  = {
+
+				// then( f1, f2, ...)
+				then: function() {
+
+					if ( ! cancelled ) {
+
+						var args = arguments,
+							i,
+							type,
+							_fired;
+
+						if ( fired ) {
+							_fired = fired;
+							fired = 0;
+						}
+
+						for ( i in args ) {
+							i = args[ i ];
+							type = jQuery.type( i );
+							if ( type === "array" ) {
+								this.then.apply( this , i );
+							} else if ( type === "function" ) {
+								callbacks.push( i );
+							}
+						}
+
+						if ( _fired ) {
+							deferred.fire( _fired[ 0 ] , _fired[ 1 ] );
+						}
+					}
+					return this;
+				},
+
+				// resolve with given context and args
+				// (i is used internally)
+				fire: function( context , args , i ) {
+					if ( ! cancelled && ! fired && ! firing ) {
+						firing = 1;
+						try {
+							for( i = 0 ; ! cancelled && callbacks[ i ] ; i++ ) {
+								cancelled = ( callbacks[ i ].apply( context , args ) === false ) && cancellable;
+							}
+						} catch( e ) {
+							cancelled = cancellable;
+							jQuery.error( e );
+						} finally {
+							fired = [ context , args ];
+							callbacks = cancelled ? [] : callbacks.slice( i + 1 );
+							firing = 0;
+						}
+					}
+					return this;
+				},
+
+				// resolve with this as context and given arguments
+				resolve: function() {
+					deferred.fire( this , arguments );
+					return this;
+				},
+
+				// cancelling further callbacks
+				cancel: function() {
+					if ( cancellable ) {
+						callbacks = [];
+						cancelled = 1;
+					}
+					return this;
+				}
+
+			};
+
+		// Add the deferred marker
+		deferred.then._ = deferredMarker;
+
+		return deferred;
+	},
+
+	// Full fledged deferred (two callbacks list)
+	// Typical success/error system
+	deferred: function( func , cancellable ) {
+
+		// Handle varargs
+		if ( arguments.length === 1 ) {
+
+			if ( typeof func === "boolean" ) {
+				cancellable = func;
+				func = 0;
+			}
+		}
+
+		var errorDeferred = jQuery._deferred( cancellable ),
+			deferred = jQuery._deferred( cancellable ),
+			// Keep reference of the cancel method since we'll redefine it
+			cancelThen = deferred.cancel;
+
+		// Add errorDeferred methods and redefine cancel			
+		jQuery.extend( deferred , {
+
+				fail: errorDeferred.then,
+				fireReject: errorDeferred.fire,
+				reject: errorDeferred.resolve,
+				cancel: function() {
+					cancelThen();
+					errorDeferred.cancel();
+					return this;
+				}
+
+		} );
+
+		// Make sure only one callback list will be used
+		deferred.then( errorDeferred.cancel ).fail( cancelThen );
+
+		// Call given func if any
+		if ( func ) {
+			func.call( deferred , deferred );
+		}
+
+		return deferred;
+	},
+
+	// Check if an object is a deferred
+	isDeferred: function( object , method ) {
+		method = method || "then";
+		return !!( object && object[ method ] && object[ method ]._ === deferredMarker );
+	},
+
+	// Deferred helper
+	when: function( object , method ) {
+		method = method || "then";
+		object = jQuery.isDeferred( object , method ) ?
+			object :
+			jQuery.deferred().resolve( object );
+		object.fail = object.fail || function() { return this; };
+		object[ method ] = object[ method ] || object.then;
+		object.then = object.then || object[ method ];
+		return object;
+	},
 
 	// Use of jQuery.browser is frowned upon.
 	// More details: http://docs.jquery.com/Utilities/jQuery.browser
@@ -818,6 +953,11 @@ jQuery.extend({
 	browser: {}
 });
 
+// Create readyList deferred
+// also force $.fn.ready to be recognized as a defer
+readyList = jQuery._deferred( false );
+jQuery.fn.ready._ = deferredMarker;
+
 // Populate the class2type map
 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
 	class2type[ "[object " + name + "]" ] = name.toLowerCase();