Permalink
Showing
with
787 additions
and 273 deletions.
- +1 −0 .gitignore
- +2 −0 Makefile
- +4 −4 src/ajax.js
- +257 −0 src/callbacks.js
- +3 −3 src/core.js
- +86 −146 src/deferred.js
- +3 −3 src/queue.js
- +45 −0 src/topic.js
- +2 −0 test/data/offset/absolute.html
- +2 −0 test/data/offset/body.html
- +2 −0 test/data/offset/fixed.html
- +2 −0 test/data/offset/relative.html
- +2 −0 test/data/offset/scroll.html
- +2 −0 test/data/offset/static.html
- +2 −0 test/data/offset/table.html
- +2 −0 test/data/support/bodyBackground.html
- +2 −0 test/data/support/boxModelIE.html
- +2 −0 test/data/support/hiddenIFrameFF.html
- +4 −0 test/index.html
- +194 −0 test/unit/callbacks.js
- +100 −117 test/unit/deferred.js
- +68 −0 test/unit/topic.js
1
.gitignore
2
Makefile
8
src/ajax.js
257
src/callbacks.js
| @@ -0,0 +1,257 @@ | ||
| +(function( jQuery ) { | ||
| + | ||
| +// String to Object flags format cache | ||
| +var flagsCache = {}; | ||
| + | ||
| +// Convert String-formatted flags into Object-formatted ones and store in cache | ||
| +function createFlags( flags ) { | ||
| + var object = flagsCache[ flags ] = {}, | ||
| + i, length; | ||
| + flags = flags.split( /\s+/ ); | ||
| + for ( i = 0, length = flags.length; i < length; i++ ) { | ||
| + object[ flags[i] ] = true; | ||
| + } | ||
| + return object; | ||
| +} | ||
| + | ||
| +/* | ||
| + * Create a callback list using the following parameters: | ||
| + * | ||
| + * flags: an optional list of space-separated flags that will change how | ||
| + * the callback list behaves | ||
| + * | ||
| + * filter: an optional function that will be applied to each added callbacks, | ||
| + * what filter returns will then be added provided it is not falsy. | ||
| + * | ||
| + * By default a callback list will act like an event callback list and can be | ||
| + * "fired" multiple times. | ||
| + * | ||
| + * Possible flags: | ||
| + * | ||
| + * once: will ensure the callback list can only be fired once (like a Deferred) | ||
| + * | ||
| + * memory: will keep track of previous values and will call any callback added | ||
| + * after the list has been fired right away with the latest "memorized" | ||
| + * values (like a Deferred) | ||
| + * | ||
| + * queue: only first callback in the list is called each time the list is fired | ||
| + * (cannot be used in conjunction with memory) | ||
| + * | ||
| + * unique: will ensure a callback can only be added once (no duplicate in the list) | ||
| + * | ||
| + * relocate: like "unique" but will relocate the callback at the end of the list | ||
| + * | ||
| + * stopOnFalse: interrupt callings when a callback returns false | ||
| + * | ||
| + * addAfterFire: if callbacks are added while firing, then they are not executed until after | ||
| + * the next call to fire/fireWith | ||
| + * | ||
| + */ | ||
| +jQuery.Callbacks = function( flags, filter ) { | ||
| + | ||
| + // flags are optional | ||
| + if ( typeof flags !== "string" ) { | ||
| + filter = flags; | ||
| + flags = undefined; | ||
| + } | ||
| + | ||
| + // Convert flags from String-formatted to Object-formatted | ||
| + // (we check in cache first) | ||
| + flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {}; | ||
| + | ||
| + var // Actual callback list | ||
| + list = [], | ||
| + // Stack of fire calls for repeatable lists | ||
| + stack = [], | ||
| + // Last fire value (for non-forgettable lists) | ||
| + memory, | ||
| + // Flag to know if list is currently firing | ||
| + firing, | ||
| + // First callback to fire (used internally by add and fireWith) | ||
| + firingStart, | ||
| + // End of the loop when firing | ||
| + firingLength, | ||
| + // Index of currently firing callback (modified by remove if needed) | ||
| + firingIndex, | ||
| + // Add one or several callbacks to the list | ||
| + add = function( args ) { | ||
| + var i, | ||
| + length, | ||
| + elem, | ||
| + type, | ||
| + actual; | ||
| + for ( i = 0, length = args.length; i < length; i++ ) { | ||
| + elem = args[ i ]; | ||
| + type = jQuery.type( elem ); | ||
| + if ( type === "array" ) { | ||
| + // Inspect recursively | ||
| + add( elem ); | ||
| + } else if ( type === "function" ) { | ||
| + // If we have to relocate, we remove the callback | ||
| + // if it already exists | ||
| + if ( flags.relocate ) { | ||
| + self.remove( elem ); | ||
| + // Skip if we're in unique mode and callback is already in | ||
| + } else if ( flags.unique && self.has( elem ) ) { | ||
| + continue; | ||
| + } | ||
| + // Get the filtered function if needs be | ||
| + actual = filter ? filter( elem ) : elem; | ||
| + if ( actual ) { | ||
| + list.push( [ elem, actual ] ); | ||
| + } | ||
| + } | ||
| + } | ||
| + }, | ||
| + // Fire callbacks | ||
| + fire = function( context, args ) { | ||
| + args = args || []; | ||
| + memory = !flags.memory || [ context, args ]; | ||
| + firing = true; | ||
| + firingIndex = firingStart || 0; | ||
| + firingStart = 0; | ||
| + firingLength = list.length; | ||
| + for ( ; list && firingIndex < firingLength; firingIndex++ ) { | ||
| + if ( list[ firingIndex ][ 1 ].apply( context, args ) === false && flags.stopOnFalse ) { | ||
| + memory = true; // Mark as halted | ||
| + break; | ||
| + } else if ( flags.queue ) { | ||
| + list.splice( firingIndex, 1 ); | ||
| + break; | ||
| + } | ||
| + } | ||
| + firing = false; | ||
| + if ( list ) { | ||
| + if ( !flags.once ) { | ||
| + if ( stack && stack.length ) { | ||
| + memory = stack.shift(); | ||
| + self.fireWith( memory[ 0 ], memory[ 1 ] ); | ||
| + } | ||
| + } else if ( memory === true ) { | ||
| + self.disable(); | ||
| + } else { | ||
| + list = []; | ||
| + } | ||
| + } | ||
| + }, | ||
| + // Actual Callbacks object | ||
| + self = { | ||
| + // Add a callback or a collection of callbacks to the list | ||
| + add: function() { | ||
| + if ( list ) { | ||
| + var length = list.length; | ||
| + add( arguments ); | ||
| + // Do we need to add the callbacks to the | ||
| + // current firing batch? | ||
| + if ( firing ) { | ||
| + if ( !flags.addAfterFire ) { | ||
| + firingLength = list.length; | ||
| + } | ||
| + // With memory, if we're not firing then | ||
| + // we should call right away, unless previous | ||
| + // firing was halted (stopOnFalse) | ||
| + } else if ( memory && memory !== true ) { | ||
| + firingStart = length; | ||
| + fire( memory[ 0 ], memory[ 1 ] ); | ||
| + } | ||
| + } | ||
| + return this; | ||
| + }, | ||
| + // Remove a callback from the list | ||
| + remove: function() { | ||
| + if ( list ) { | ||
| + var args = arguments, | ||
| + argIndex = 0, | ||
| + argLength = args.length; | ||
| + for ( ; argIndex < argLength ; argIndex++ ) { | ||
| + for ( var i = 0; i < list.length; i++ ) { | ||
| + if ( args[ argIndex ] === list[ i ][ 0 ] ) { | ||
| + // Handle firingIndex and firingLength | ||
| + if ( firing ) { | ||
| + if ( i <= firingLength ) { | ||
| + firingLength--; | ||
| + if ( i <= firingIndex ) { | ||
| + firingIndex--; | ||
| + } | ||
| + } | ||
| + } | ||
| + // Remove the element | ||
| + list.splice( i--, 1 ); | ||
| + // If we have some unicity property then | ||
| + // we only need to do this once | ||
| + if ( flags.unique || flags.relocate ) { | ||
| + break; | ||
| + } | ||
| + } | ||
| + } | ||
| + } | ||
| + } | ||
| + return this; | ||
| + }, | ||
| + // Control if a given callback is in the list | ||
| + has: function( fn ) { | ||
| + if ( list ) { | ||
| + var i = 0, | ||
| + length = list.length; | ||
| + for ( ; i < length; i++ ) { | ||
| + if ( fn === list[ i ][ 0 ] ) { | ||
| + return true; | ||
| + } | ||
| + } | ||
| + } | ||
| + return false; | ||
| + }, | ||
| + // Remove all callbacks from the list | ||
| + empty: function() { | ||
| + list = []; | ||
| + return this; | ||
| + }, | ||
| + // Have the list do nothing anymore | ||
| + disable: function() { | ||
| + list = stack = memory = undefined; | ||
| + return this; | ||
| + }, | ||
| + // Is it disabled? | ||
| + disabled: function() { | ||
| + return !list; | ||
| + }, | ||
| + // Lock the list in its current state | ||
| + lock: function() { | ||
| + stack = undefined; | ||
| + if ( !memory || memory === true ) { | ||
| + self.disable(); | ||
| + } | ||
| + return this; | ||
| + }, | ||
| + // Is it locked? | ||
| + locked: function() { | ||
| + return !stack; | ||
| + }, | ||
| + // Call all callbacks with the given context and arguments | ||
| + fireWith: function( context, args ) { | ||
| + if ( stack ) { | ||
| + if ( firing ) { | ||
| + if ( !flags.once ) { | ||
| + stack.push( [ context, args ] ); | ||
| + } | ||
| + } else if ( !( flags.once && memory ) ) { | ||
| + fire( context, args ); | ||
| + } | ||
| + } | ||
| + return this; | ||
| + }, | ||
| + // Call all the callbacks with the given arguments | ||
| + fire: function() { | ||
| + self.fireWith( this, arguments ); | ||
| + return this; | ||
| + }, | ||
| + // To know if the callbacks have already been called at least once | ||
| + fired: function() { | ||
| + return !!memory; | ||
| + } | ||
| + }; | ||
| + | ||
| + return self; | ||
| +}; | ||
| + | ||
| +})( jQuery ); |
6
src/core.js
232
src/deferred.js
6
src/queue.js
45
src/topic.js
| @@ -0,0 +1,45 @@ | ||
| +(function( jQuery ) { | ||
| + | ||
| + var topics = {}, | ||
| + sliceTopic = [].slice; | ||
| + | ||
| + jQuery.Topic = function( id ) { | ||
| + var callbacks, | ||
| + method, | ||
| + topic = id && topics[ id ]; | ||
| + if ( !topic ) { | ||
| + callbacks = jQuery.Callbacks(); | ||
| + topic = { | ||
| + publish: callbacks.fire, | ||
| + subscribe: callbacks.add, | ||
| + unsubscribe: callbacks.remove | ||
| + }; | ||
| + if ( id ) { | ||
| + topics[ id ] = topic; | ||
| + } | ||
| + } | ||
| + return topic; | ||
| + }; | ||
| + | ||
| + jQuery.extend({ | ||
| + subscribe: function( id ) { | ||
| + var topic = jQuery.Topic( id ), | ||
| + args = sliceTopic.call( arguments, 1 ); | ||
| + topic.subscribe.apply( topic, args ); | ||
| + return { | ||
| + topic: topic, | ||
| + args: args | ||
| + }; | ||
| + }, | ||
| + unsubscribe: function( id ) { | ||
| + var topic = id && id.topic || jQuery.Topic( id ); | ||
| + topic.unsubscribe.apply( topic, id && id.args || | ||
| + sliceTopic.call( arguments, 1 ) ); | ||
| + }, | ||
| + publish: function( id ) { | ||
| + var topic = jQuery.Topic( id ); | ||
| + topic.publish.apply( topic, sliceTopic.call( arguments, 1 ) ); | ||
| + } | ||
| + }); | ||
| + | ||
| +})( jQuery ); |
2
test/data/offset/absolute.html
2
test/data/offset/body.html
2
test/data/offset/fixed.html
2
test/data/offset/relative.html
2
test/data/offset/scroll.html
2
test/data/offset/static.html
2
test/data/offset/table.html
2
test/data/support/bodyBackground.html
2
test/data/support/boxModelIE.html
2
test/data/support/hiddenIFrameFF.html
4
test/index.html
194
test/unit/callbacks.js
| @@ -0,0 +1,194 @@ | ||
| +module("callbacks", { teardown: moduleTeardown }); | ||
| + | ||
| +(function() { | ||
| + | ||
| +var output, | ||
| + addToOutput = function( string ) { | ||
| + return function() { | ||
| + output += string; | ||
| + }; | ||
| + }, | ||
| + outputA = addToOutput( "A" ), | ||
| + outputB = addToOutput( "B" ), | ||
| + outputC = addToOutput( "C" ), | ||
| + tests = { | ||
| + "": "XABC X XABCABCC X XBB X XABA X", | ||
| + "once": "XABC X X X X X XABA X", | ||
| + "memory": "XABC XABC XABCABCCC XA XBB XB XABA XC", | ||
| + "unique": "XABC X XABCA X XBB X XAB X", | ||
| + "relocate": "XABC X XAABC X XBB X XBA X", | ||
| + "stopOnFalse": "XABC X XABCABCC X XBB X XA X", | ||
| + "addAfterFire": "XAB X XABCAB X XBB X XABA X", | ||
| + "queue": "XA X XB X XB X XA X", | ||
| + "once memory": "XABC XABC X XA X XA XABA XC", | ||
| + "once unique": "XABC X X X X X XAB X", | ||
| + "once relocate": "XABC X X X X X XBA X", | ||
| + "once stopOnFalse": "XABC X X X X X XA X", | ||
| + "once addAfterFire": "XAB X X X X X XABA X", | ||
| + "memory unique": "XABC XA XABCA XA XBB XB XAB XC", | ||
| + "memory relocate": "XABC XB XAABC XA XBB XB XBA XC", | ||
| + "memory stopOnFalse": "XABC XABC XABCABCCC XA XBB XB XA X", | ||
| + "memory addAfterFire": "XAB XAB XABCABC XA XBB XB XABA XC", | ||
| + "unique relocate": "XABC X XAABC X XBB X XBA X", | ||
| + "unique stopOnFalse": "XABC X XABCA X XBB X XA X", | ||
| + "unique addAfterFire": "XAB X XABCA X XBB X XAB X", | ||
| + "relocate stopOnFalse": "XABC X XAABC X XBB X X X", | ||
| + "relocate addAfterFire": "XAB X XAA X XBB X XBA X", | ||
| + "stopOnFalse addAfterFire": "XAB X XABCAB X XBB X XA X" | ||
| + }, | ||
| + filters = { | ||
| + "no filter": undefined, | ||
| + "filter": function( fn ) { | ||
| + return function() { | ||
| + return fn.apply( this, arguments ); | ||
| + }; | ||
| + } | ||
| + }; | ||
| + | ||
| +jQuery.each( tests, function( flags, resultString ) { | ||
| + | ||
| + jQuery.each( filters, function( filterLabel, filter ) { | ||
| + | ||
| + test( "jQuery.Callbacks( \"" + flags + "\" ) - " + filterLabel, function() { | ||
| + | ||
| + expect( 19 ); | ||
| + | ||
| + // 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" ); | ||
| + 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() { | ||
| + equals( 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() { | ||
| + equals( 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" ); | ||
| + | ||
| + // 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 ); | ||
| + strictEqual( output, results.shift(), "Adding a callback after one returned false" ); | ||
| + | ||
| + }); | ||
| + }); | ||
| +}); | ||
| + | ||
| +})(); |
217
test/unit/deferred.js
68
test/unit/topic.js
| @@ -0,0 +1,68 @@ | ||
| +module("topic", { teardown: moduleTeardown }); | ||
| + | ||
| +test( "jQuery.Topic - Anonymous Topic", function() { | ||
| + | ||
| + expect( 4 ); | ||
| + | ||
| + var topic = jQuery.Topic(), | ||
| + count = 0; | ||
| + | ||
| + function firstCallback( value ) { | ||
| + strictEqual( count, 1, "Callback called when needed" ); | ||
| + strictEqual( value, "test", "Published value received" ); | ||
| + } | ||
| + | ||
| + count++; | ||
| + topic.subscribe( firstCallback ); | ||
| + topic.publish( "test" ); | ||
| + topic.unsubscribe( firstCallback ); | ||
| + count++; | ||
| + topic.subscribe(function( value ) { | ||
| + strictEqual( count, 2, "Callback called when needed" ); | ||
| + strictEqual( value, "test", "Published value received" ); | ||
| + }); | ||
| + topic.publish( "test" ); | ||
| + | ||
| +}); | ||
| + | ||
| +test( "jQuery.Topic - Named Topic", function() { | ||
| + | ||
| + expect( 2 ); | ||
| + | ||
| + function callback( value ) { | ||
| + ok( true, "Callback called" ); | ||
| + strictEqual( value, "test", "Proper value received" ); | ||
| + } | ||
| + | ||
| + jQuery.Topic( "test" ).subscribe( callback ); | ||
| + jQuery.Topic( "test" ).publish( "test" ); | ||
| + jQuery.Topic( "test" ).unsubscribe( callback ); | ||
| + jQuery.Topic( "test" ).publish( "test" ); | ||
| +}); | ||
| + | ||
| +test( "jQuery.Topic - Helpers", function() { | ||
| + | ||
| + expect( 4 ); | ||
| + | ||
| + function callback( value ) { | ||
| + ok( true, "Callback called" ); | ||
| + strictEqual( value, "test", "Proper value received" ); | ||
| + } | ||
| + | ||
| + jQuery.subscribe( "test", callback ); | ||
| + jQuery.publish( "test" , "test" ); | ||
| + jQuery.unsubscribe( "test", callback ); | ||
| + jQuery.publish( "test" , "test" ); | ||
| + | ||
| + | ||
| + var test = true, | ||
| + subscription = jQuery.subscribe( "test", function() { | ||
| + ok( test, "first callback called" ); | ||
| + }, function() { | ||
| + ok( test, "second callback called" ); | ||
| + }); | ||
| + jQuery.publish( "test" ); | ||
| + test = false; | ||
| + jQuery.unsubscribe( subscription ); | ||
| + jQuery.publish( "test" ); | ||
| +}); |