Allows traditional options object for $.Callbacks flags. Fixes #11011. Unit tests...

diff --git a/src/callbacks.js b/src/callbacks.js
index 387868604ecb6a967c4411b364adfc925eb9be61..20422c35a0918f6647ea6a1bb42ad35379d87a90 100644 (file)
--- a/src/callbacks.js
+++ b/src/callbacks.js
@@ -38,9 +38,9 @@ function createFlags( flags ) {
  */
 jQuery.Callbacks = function( flags ) {
 
-       // Convert flags from String-formatted to Object-formatted
+       // Convert flags from String-formatted to Object-formatted if needed
        // (we check in cache first)
-       flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {};
+       flags = typeof flags === "string" ? ( flagsCache[ flags ] || createFlags( flags ) ) : ( flags || {} );
 
        var // Actual callback list
                list = [],

diff --git a/test/unit/callbacks.js b/test/unit/callbacks.js
index acc88f2c24830ec9bdfddc225b816604192d5c43..acc61f32cf28cdda75fdc83db70d326423d7d82d 100644 (file)
--- a/test/unit/callbacks.js
+++ b/test/unit/callbacks.js
@@ -33,149 +33,171 @@ var output,
                }
        };
 
-jQuery.each( tests, function( flags, resultString ) {
-
-               jQuery.each( filters, function( filterLabel, filter ) {
-
-                       test( "jQuery.Callbacks( \"" + flags + "\" ) - " + filterLabel, function() {
+       function showFlags( flags ) {
+               if ( typeof flags === "string" ) {
+                       return '"' + flags + '"';
+               }
+               var output = [], key;
+               for ( key in flags ) {
+                       output.push( '"' + key + '": ' + flags[ key ] );
+               }
+               return "{ " + output.join( ", " ) + " }";
+       }
 
-                               expect( 20 );
+jQuery.each( tests, function( strFlags, resultString ) {
 
-                               // Give qunit a little breathing room
-                               stop();
-                               setTimeout( start, 0 );
+               var objectFlags = {};
 
-                               var cblist;
-                                       results = resultString.split( /\s+/ );
+               jQuery.each( strFlags.split( " " ), function() {
+                       if ( this.length ) {
+                               objectFlags[ this ] = true;
+                       }
+               });
 
-                               // Basic binding and firing
-                               output = "X";
-                               cblist = jQuery.Callbacks( flags );
-                               cblist.add(function( str ) {
-                                       output += str;
-                               });
-                               cblist.fire( "A" );
-                               strictEqual( output, "XA", "Basic binding and firing" );
-                               strictEqual( cblist.fired(), true, ".fired() detects firing" );
-                               output = "X";
-                               cblist.disable();
-                               cblist.add(function( str ) {
-                                       output += str;
-                               });
-                               strictEqual( output, "X", "Adding a callback after disabling" );
-                               cblist.fire( "A" );
-                               strictEqual( output, "X", "Firing after disabling" );
-
-                               // Basic binding and firing (context, arguments)
-                               output = "X";
-                               cblist = jQuery.Callbacks( flags );
-                               cblist.add(function() {
-                                       equal( this, window, "Basic binding and firing (context)" );
-                                       output += Array.prototype.join.call( arguments, "" );
-                               });
-                               cblist.fireWith( window, [ "A", "B" ] );
-                               strictEqual( output, "XAB", "Basic binding and firing (arguments)" );
-
-                               // fireWith with no arguments
-                               output = "";
-                               cblist = jQuery.Callbacks( flags );
-                               cblist.add(function() {
-                                       equal( this, window, "fireWith with no arguments (context is window)" );
-                                       strictEqual( arguments.length, 0, "fireWith with no arguments (no arguments)" );
-                               });
-                               cblist.fireWith();
-
-                               // Basic binding, removing and firing
-                               output = "X";
-                               cblist = jQuery.Callbacks( flags );
-                               cblist.add( outputA, outputB, outputC );
-                               cblist.remove( outputB, outputC );
-                               cblist.fire();
-                               strictEqual( output, "XA", "Basic binding, removing and firing" );
-
-                               // Empty
-                               output = "X";
-                               cblist = jQuery.Callbacks( flags );
-                               cblist.add( outputA );
-                               cblist.add( outputB );
-                               cblist.add( outputC );
-                               cblist.empty();
-                               cblist.fire();
-                               strictEqual( output, "X", "Empty" );
-
-                               // Locking
-                               output = "X";
-                               cblist = jQuery.Callbacks( flags );
-                               cblist.add( function( str ) {
-                                       output += str;
-                               });
-                               cblist.lock();
-                               cblist.add( function( str ) {
-                                       output += str;
-                               });
-                               cblist.fire( "A" );
-                               cblist.add( function( str ) {
-                                       output += str;
-                               });
-                               strictEqual( output, "X", "Lock early" );
+               jQuery.each( filters, function( filterLabel, filter ) {
 
-                               // Ordering
-                               output = "X";
-                               cblist = jQuery.Callbacks( flags );
-                               cblist.add( function() {
+                       jQuery.each( { "string": strFlags, "object": objectFlags }, function( flagsTypes, flags ) {
+
+                               test( "jQuery.Callbacks( " + showFlags( flags ) + " ) - " + filterLabel, function() {
+
+                                       expect( 20 );
+
+                                       // Give qunit a little breathing room
+                                       stop();
+                                       setTimeout( start, 0 );
+
+                                       var cblist;
+                                               results = resultString.split( /\s+/ );
+
+                                       // Basic binding and firing
+                                       output = "X";
+                                       cblist = jQuery.Callbacks( flags );
+                                       cblist.add(function( str ) {
+                                               output += str;
+                                       });
+                                       cblist.fire( "A" );
+                                       strictEqual( output, "XA", "Basic binding and firing" );
+                                       strictEqual( cblist.fired(), true, ".fired() detects firing" );
+                                       output = "X";
+                                       cblist.disable();
+                                       cblist.add(function( str ) {
+                                               output += str;
+                                       });
+                                       strictEqual( output, "X", "Adding a callback after disabling" );
+                                       cblist.fire( "A" );
+                                       strictEqual( output, "X", "Firing after disabling" );
+
+                                       // Basic binding and firing (context, arguments)
+                                       output = "X";
+                                       cblist = jQuery.Callbacks( flags );
+                                       cblist.add(function() {
+                                               equal( this, window, "Basic binding and firing (context)" );
+                                               output += Array.prototype.join.call( arguments, "" );
+                                       });
+                                       cblist.fireWith( window, [ "A", "B" ] );
+                                       strictEqual( output, "XAB", "Basic binding and firing (arguments)" );
+
+                                       // fireWith with no arguments
+                                       output = "";
+                                       cblist = jQuery.Callbacks( flags );
+                                       cblist.add(function() {
+                                               equal( this, window, "fireWith with no arguments (context is window)" );
+                                               strictEqual( arguments.length, 0, "fireWith with no arguments (no arguments)" );
+                                       });
+                                       cblist.fireWith();
+
+                                       // Basic binding, removing and firing
+                                       output = "X";
+                                       cblist = jQuery.Callbacks( flags );
+                                       cblist.add( outputA, outputB, outputC );
+                                       cblist.remove( outputB, outputC );
+                                       cblist.fire();
+                                       strictEqual( output, "XA", "Basic binding, removing and firing" );
+
+                                       // Empty
+                                       output = "X";
+                                       cblist = jQuery.Callbacks( flags );
+                                       cblist.add( outputA );
+                                       cblist.add( outputB );
                                        cblist.add( outputC );
-                                       outputA();
-                               }, outputB );
-                               cblist.fire();
-                               strictEqual( output, results.shift(), "Proper ordering" );
-
-                               // Add and fire again
-                               output = "X";
-                               cblist.add( function() {
+                                       cblist.empty();
+                                       cblist.fire();
+                                       strictEqual( output, "X", "Empty" );
+
+                                       // Locking
+                                       output = "X";
+                                       cblist = jQuery.Callbacks( flags );
+                                       cblist.add( function( str ) {
+                                               output += str;
+                                       });
+                                       cblist.lock();
+                                       cblist.add( function( str ) {
+                                               output += str;
+                                       });
+                                       cblist.fire( "A" );
+                                       cblist.add( function( str ) {
+                                               output += str;
+                                       });
+                                       strictEqual( output, "X", "Lock early" );
+
+                                       // Ordering
+                                       output = "X";
+                                       cblist = jQuery.Callbacks( flags );
+                                       cblist.add( function() {
+                                               cblist.add( outputC );
+                                               outputA();
+                                       }, outputB );
+                                       cblist.fire();
+                                       strictEqual( output, results.shift(), "Proper ordering" );
+
+                                       // Add and fire again
+                                       output = "X";
+                                       cblist.add( function() {
+                                               cblist.add( outputC );
+                                               outputA();
+                                       }, outputB );
+                                       strictEqual( output, results.shift(), "Add after fire" );
+
+                                       output = "X";
+                                       cblist.fire();
+                                       strictEqual( output, results.shift(), "Fire again" );
+
+                                       // Multiple fire
+                                       output = "X";
+                                       cblist = jQuery.Callbacks( flags );
+                                       cblist.add( function( str ) {
+                                               output += str;
+                                       } );
+                                       cblist.fire( "A" );
+                                       strictEqual( output, "XA", "Multiple fire (first fire)" );
+                                       output = "X";
+                                       cblist.add( function( str ) {
+                                               output += str;
+                                       } );
+                                       strictEqual( output, results.shift(), "Multiple fire (first new callback)" );
+                                       output = "X";
+                                       cblist.fire( "B" );
+                                       strictEqual( output, results.shift(), "Multiple fire (second fire)" );
+                                       output = "X";
+                                       cblist.add( function( str ) {
+                                               output += str;
+                                       } );
+                                       strictEqual( output, results.shift(), "Multiple fire (second new callback)" );
+
+                                       // Return false
+                                       output = "X";
+                                       cblist = jQuery.Callbacks( flags );
+                                       cblist.add( outputA, function() { return false; }, outputB );
+                                       cblist.add( outputA );
+                                       cblist.fire();
+                                       strictEqual( output, results.shift(), "Callback returning false" );
+
+                                       // Add another callback (to control lists with memory do not fire anymore)
+                                       output = "X";
                                        cblist.add( outputC );
-                                       outputA();
-                               }, outputB );
-                               strictEqual( output, results.shift(), "Add after fire" );
-
-                               output = "X";
-                               cblist.fire();
-                               strictEqual( output, results.shift(), "Fire again" );
-
-                               // Multiple fire
-                               output = "X";
-                               cblist = jQuery.Callbacks( flags );
-                               cblist.add( function( str ) {
-                                       output += str;
-                               } );
-                               cblist.fire( "A" );
-                               strictEqual( output, "XA", "Multiple fire (first fire)" );
-                               output = "X";
-                               cblist.add( function( str ) {
-                                       output += str;
-                               } );
-                               strictEqual( output, results.shift(), "Multiple fire (first new callback)" );
-                               output = "X";
-                               cblist.fire( "B" );
-                               strictEqual( output, results.shift(), "Multiple fire (second fire)" );
-                               output = "X";
-                               cblist.add( function( str ) {
-                                       output += str;
-                               } );
-                               strictEqual( output, results.shift(), "Multiple fire (second new callback)" );
-
-                               // Return false
-                               output = "X";
-                               cblist = jQuery.Callbacks( flags );
-                               cblist.add( outputA, function() { return false; }, outputB );
-                               cblist.add( outputA );
-                               cblist.fire();
-                               strictEqual( output, results.shift(), "Callback returning false" );
-
-                               // Add another callback (to control lists with memory do not fire anymore)
-                               output = "X";
-                               cblist.add( outputC );
-                               strictEqual( output, results.shift(), "Adding a callback after one returned false" );
+                                       strictEqual( output, results.shift(), "Adding a callback after one returned false" );
 
+                               });
                        });
                });
 });