From: Rick Waldron Date: Mon, 31 Dec 2012 20:09:45 +0000 (-0500) Subject: 2.0: Rewrite data.js X-Git-Tag: 2.0.0b1~53 X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=d1de3000c6d50c298de14fb1ae3381d75c303723;p=jquery.git 2.0: Rewrite data.js Signed-off-by: Rick Waldron --- diff --git a/src/data.js b/src/data.js index d5a25ff6c..b8e7b1de5 100644 --- a/src/data.js +++ b/src/data.js @@ -1,232 +1,178 @@ -var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/, +var user, priv, + rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/, rmultiDash = /([A-Z])/g; - -function internalData( elem, name, data, pvt /* Internal Use Only */ ){ - if ( !jQuery.acceptData( elem ) ) { - return; - } - - var thisCache, ret, - internalKey = jQuery.expando, - getByName = typeof name === "string", - - // We have to handle DOM nodes and JS objects differently because IE6-7 - // can't GC object references properly across the DOM-JS boundary - isNode = elem.nodeType, - - // Only DOM nodes need the global jQuery cache; JS object data is - // attached directly to the object so GC can occur automatically - cache = isNode ? jQuery.cache : elem, - - // Only defining an ID for JS objects if its cache already exists allows - // the code to shortcut on the same path as a DOM node with no cache - id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey; - - // Avoid doing any more work than we need to when trying to get data on an - // object that has no data at all - if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) { - return; - } - if ( !id ) { - // Only DOM nodes need a new unique ID for each element since their data - // ends up in the global cache - if ( isNode ) { - elem[ internalKey ] = id = core_deletedIds.pop() || jQuery.guid++; - } else { - id = internalKey; - } - } +function Data() { + // Nodes|Objects + this.owners = []; + // Data objects + this.cache = []; +} - if ( !cache[ id ] ) { - cache[ id ] = {}; +Data.prototype = { + add: function( owner ) { + this.owners.push( owner ); + return (this.cache[ this.owners.length - 1 ] = {}); + }, + set: function( owner, data, value ) { + var prop, + index = this.owners.indexOf( owner ); - // Avoids exposing jQuery metadata on plain JS objects when the object - // is serialized using JSON.stringify - if ( !isNode ) { - cache[ id ].toJSON = jQuery.noop; + if ( index === -1 ) { + this.add( owner ); + index = this.owners.length - 1; } - } - - // An object can be passed to jQuery.data instead of a key/value pair; this gets - // shallow copied over onto the existing cache - if ( typeof name === "object" || typeof name === "function" ) { - if ( pvt ) { - cache[ id ] = jQuery.extend( cache[ id ], name ); + if ( typeof data === "string" ) { + this.cache[ index ][ data ] = value; } else { - cache[ id ].data = jQuery.extend( cache[ id ].data, name ); - } - } - - thisCache = cache[ id ]; - // jQuery data() is stored in a separate object inside the object's internal data - // cache in order to avoid key collisions between internal data and user-defined - // data. - if ( !pvt ) { - if ( !thisCache.data ) { - thisCache.data = {}; + if ( jQuery.isEmptyObject( this.cache[ index ] ) ) { + this.cache[ index ] = data; + } else { + for ( prop in data ) { + this.cache[ index ][ prop ] = data[ prop ]; + } + } } + return this; + }, + get: function( owner, key ) { + var cache, + index = this.owners.indexOf( owner ); + + // A valid cache is found, or needs to be created. + // New entries will be added and return the current + // empty data object to be used as a return reference + // return this.add( owner ); + cache = index === -1 ? + this.add( owner ) : this.cache[ index ]; + + return key === undefined ? + cache : cache[ key ]; + }, + access: function( owner, key, value ) { + if ( value === undefined && (key && typeof key !== "object") ) { + // Assume this is a request to read the cached data + return this.get( owner, key ); + } else { - thisCache = thisCache.data; - } - - if ( data !== undefined ) { - thisCache[ jQuery.camelCase( name ) ] = data; - } - - // Check for both converted-to-camel and non-converted data property names - // If a data property was specified - if ( getByName ) { - - // First Try to find as-is property data - ret = thisCache[ name ]; - - // Test for null|undefined property data - if ( ret == null ) { + // If only an owner was specified, return the entire + // cache object. + if ( key === undefined ) { + return this.get( owner ); + } - // Try to find the camelCased property - ret = thisCache[ jQuery.camelCase( name ) ]; + // Allow setting or extending (existing objects) with an + // object of properties, or a key and val + this.set( owner, key, value ); + return value !== undefined ? value : key; } - } else { - ret = thisCache; - } - - return ret; -} - -function internalRemoveData( elem, name, pvt /* For internal use only */ ){ - if ( !jQuery.acceptData( elem ) ) { - return; - } - - var thisCache, i, l, - - isNode = elem.nodeType, - - // See jQuery.data for more information - cache = isNode ? jQuery.cache : elem, - id = isNode ? elem[ jQuery.expando ] : jQuery.expando; - - // If there is already no cache entry for this object, there is no - // purpose in continuing - if ( !cache[ id ] ) { - return; - } - - if ( name ) { - - thisCache = pvt ? cache[ id ] : cache[ id ].data; - - if ( thisCache ) { - - // Support array or space separated string names for data keys - if ( !jQuery.isArray( name ) ) { - - // try the string as a key before any manipulation - if ( name in thisCache ) { - name = [ name ]; - } else { + // Otherwise, this is a read request. + return this.get( owner, key ); + }, + remove: function( owner, key ) { + var i, l, name, + camel = jQuery.camelCase, + index = this.owners.indexOf( owner ), + cache = this.cache[ index ]; - // split the camel cased version by spaces unless a key with the spaces exists - name = jQuery.camelCase( name ); - if ( name in thisCache ) { - name = [ name ]; + if ( key === undefined ) { + cache = {}; + } else { + if ( cache ) { + // Support array or space separated string of keys + if ( !Array.isArray( key ) ) { + // Try the string as a key before any manipulation + // + + if ( key in cache ) { + name = [ key ]; } else { - name = name.split(" "); + // split the camel cased version by spaces unless a key with the spaces exists + name = camel( key ); + name = name in cache ? + [ name ] : name.split(" "); } + } else { + // If "name" is an array of keys... + // When data is initially created, via ("key", "val") signature, + // keys will be converted to camelCase. + // Since there is no way to tell _how_ a key was added, remove + // both plain key and camelCase key. #12786 + // This will only penalize the array argument path. + name = key.concat( key.map( camel ) ); } - } else { - // If "name" is an array of keys... - // When data is initially created, via ("key", "val") signature, - // keys will be converted to camelCase. - // Since there is no way to tell _how_ a key was added, remove - // both plain key and camelCase key. #12786 - // This will only penalize the array argument path. - name = name.concat( jQuery.map( name, jQuery.camelCase ) ); - } - - for ( i = 0, l = name.length; i < l; i++ ) { - delete thisCache[ name[i] ]; - } + i = 0; + l = name.length; - // If there is no data left in the cache, we want to continue - // and let the cache object itself get destroyed - if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) { - return; + for ( ; i < l; i++ ) { + delete cache[ name[i] ]; + } } } - } - - // See jQuery.data for more information - if ( !pvt ) { - delete cache[ id ].data; + this.cache[ index ] = cache; + }, + hasData: function( owner ) { + var index = this.owners.indexOf( owner ); - // Don't destroy the parent cache unless the internal data object - // had been the only thing left in it - if ( !isEmptyDataObject( cache[ id ] ) ) { - return; + if ( index > -1 ) { + return !jQuery.isEmptyObject( this.cache[ index ] ); } + return false; + }, + discard: function( owner ) { + var index = this.owners.indexOf( owner ); + this.owners.splice( index, 1 ); + this.cache.splice( index, 1 ); + return this; } +}; - // Destroy the cache - if ( isNode ) { - jQuery.cleanData( [ elem ], true ); +// This will be used by remove() in manipulation to sever +// remaining references to node objects. One day we'll replace the dual +// arrays with a WeakMap and this won't be an issue. +// function data_discard( owner ) { + // user.discard( owner ); + // priv.discard( owner ); +// } - // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080) - } else if ( jQuery.support.deleteExpando || cache != cache.window ) { - delete cache[ id ]; +user = new Data(); +priv = new Data(); - // When all else fails, null - } else { - cache[ id ] = null; - } -} jQuery.extend({ - cache: {}, - + acceptData: function() { + return true; + }, // Unique for each copy of jQuery on the page // Non-digits removed to match rinlinejQuery expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ), - // The following elements throw uncatchable exceptions if you - // attempt to add expando properties to them. - noData: { - "embed": true, - // Ban all objects except for Flash (which handle expandos) - "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000", - "applet": true - }, - hasData: function( elem ) { - elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ]; - return !!elem && !isEmptyDataObject( elem ); + return user.hasData( elem ) || priv.hasData( elem ); }, data: function( elem, name, data ) { - return internalData( elem, name, data, false ); + return user.access( elem, name, data ); }, removeData: function( elem, name ) { - return internalRemoveData( elem, name, false ); + return user.remove( elem, name ); }, - // For internal use only. + // TODO: Replace all calls to _data and _removeData with direct + // calls to + // + // priv.access( elem, name, data ); + // + // priv.remove( elem, name ); + // _data: function( elem, name, data ) { - return internalData( elem, name, data, true ); + return priv.access( elem, name, data ); }, - - _removeData: function( elem, name ) { - return internalRemoveData( elem, name, true ); - }, - - // A method for determining if a DOM node can handle the data expando - acceptData: function( elem ) { - var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ]; - // nodes accept data unless otherwise specified; rejection can be conditional - return !noData || noData !== true && elem.getAttribute("classid") === noData; + _removeData: function( elem, name ) { + return priv.remove( elem, name ); } }); @@ -240,20 +186,19 @@ jQuery.fn.extend({ // Gets all values if ( key === undefined ) { if ( this.length ) { - data = jQuery.data( elem ); + data = user.get( elem ); - if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) { + if ( elem.nodeType === 1 && !priv.get( elem, "hasDataAttrs" ) ) { attrs = elem.attributes; for ( ; i < attrs.length; i++ ) { name = attrs[i].name; - if ( !name.indexOf( "data-" ) ) { + if ( name.indexOf( "data-" ) === 0 ) { name = jQuery.camelCase( name.substring(5) ); - dataAttr( elem, name, data[ name ] ); } } - jQuery._data( elem, "parsedAttrs", true ); + priv.set( elem, { hasDataAttrs: true }); } } @@ -263,37 +208,79 @@ jQuery.fn.extend({ // Sets multiple values if ( typeof key === "object" ) { return this.each(function() { - jQuery.data( this, key ); + user.set( this, key ); }); } return jQuery.access( this, function( value ) { + var data, + camelKey = jQuery.camelCase( key ); + // Get the Data... if ( value === undefined ) { - // Try to fetch any internally stored data first - return elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null; + + // Attempt to get data from the cache + // with the key as-is + data = user.get( elem, key ); + if ( data !== undefined ) { + return data; + } + + // Attempt to "discover" the data in + // HTML5 custom data-* attrs + data = dataAttr( elem, key, undefined ); + if ( data !== undefined ) { + return data; + } + + // As a last resort, attempt to find + // the data by checking AGAIN, but with + // a camelCased key. + data = user.get( elem, camelKey ); + if ( data !== undefined ) { + return data; + } + + // We tried really hard, but the data doesn't exist. + return undefined; } + // Set the data... this.each(function() { - jQuery.data( this, key, value ); + // First, attempt to store a copy or reference of any + // data that might've been store with a camelCased key. + var data = user.get( this, camelKey ); + + // For HTML5 data-* attribute interop, we have to + // store property names with dashes in a camelCase form. + // This might not apply to all properties...* + user.set( this, camelKey, value ); + + // *... In the case of properties that might ACTUALLY + // have dashes, we need to also store a copy of that + // unchanged property. + if ( /-/.test( key ) && data !== undefined ) { + user.set( this, key, value ); + } }); }, null, value, arguments.length > 1, null, true ); }, removeData: function( key ) { return this.each(function() { - jQuery.removeData( this, key ); + user.remove( this, key ); }); } }); function dataAttr( elem, key, data ) { + var name; + // If nothing was found internally, try to fetch any // data from the HTML5 data-* attribute if ( data === undefined && elem.nodeType === 1 ) { - var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase(); - + name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase(); data = elem.getAttribute( name ); if ( typeof data === "string" ) { @@ -303,13 +290,12 @@ function dataAttr( elem, key, data ) { data === "null" ? null : // Only convert to a number if it doesn't change the string +data + "" === data ? +data : - rbrace.test( data ) ? jQuery.parseJSON( data ) : - data; + rbrace.test( data ) ? + JSON.parse( data ) : data; } catch( e ) {} // Make sure we set the data so it isn't changed later - jQuery.data( elem, key, data ); - + user.set( elem, key, data ); } else { data = undefined; } @@ -317,20 +303,3 @@ function dataAttr( elem, key, data ) { return data; } - -// checks a cache object for emptiness -function isEmptyDataObject( obj ) { - var name; - for ( name in obj ) { - - // if the public data object is empty, the private is still empty - if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) { - continue; - } - if ( name !== "toJSON" ) { - return false; - } - } - - return true; -} diff --git a/test/data/testrunner.js b/test/data/testrunner.js index f7aca724a..6c9665867 100644 --- a/test/data/testrunner.js +++ b/test/data/testrunner.js @@ -200,47 +200,51 @@ var Globals = (function() { */ QUnit.expectJqData = function( elems, key ) { var i, elem, expando; - QUnit.current_testEnvironment.checkJqData = true; - if ( elems.jquery && elems.toArray ) { - elems = elems.toArray(); - } - if ( !jQuery.isArray( elems ) ) { - elems = [ elems ]; - } + if ( jQuery.cache ) { + QUnit.current_testEnvironment.checkJqData = true; - for ( i = 0; i < elems.length; i++ ) { - elem = elems[i]; - - // jQuery.data only stores data for nodes in jQuery.cache, - // for other data targets the data is stored in the object itself, - // in that case we can't test that target for memory leaks. - // But we don't have to since in that case the data will/must will - // be available as long as the object is not garbage collected by - // the js engine, and when it is, the data will be removed with it. - if ( !elem.nodeType ) { - // Fixes false positives for dataTests(window), dataTests({}). - continue; + if ( elems.jquery && elems.toArray ) { + elems = elems.toArray(); + } + if ( !jQuery.isArray( elems ) ) { + elems = [ elems ]; } - expando = elem[ jQuery.expando ]; - - if ( expando === undefined ) { - // In this case the element exists fine, but - // jQuery.data (or internal data) was never (in)directly - // called. - // Since this method was called it means some data was - // expected to be found, but since there is nothing, fail early - // (instead of in teardown). - notStrictEqual( expando, undefined, "Target for expectJqData must have an expando, for else there can be no data to expect." ); - } else { - if ( expectedDataKeys[expando] ) { - expectedDataKeys[expando].push( key ); + for ( i = 0; i < elems.length; i++ ) { + elem = elems[i]; + + // jQuery.data only stores data for nodes in jQuery.cache, + // for other data targets the data is stored in the object itself, + // in that case we can't test that target for memory leaks. + // But we don't have to since in that case the data will/must will + // be available as long as the object is not garbage collected by + // the js engine, and when it is, the data will be removed with it. + if ( !elem.nodeType ) { + // Fixes false positives for dataTests(window), dataTests({}). + continue; + } + + expando = elem[ jQuery.expando ]; + + if ( expando === undefined ) { + // In this case the element exists fine, but + // jQuery.data (or internal data) was never (in)directly + // called. + // Since this method was called it means some data was + // expected to be found, but since there is nothing, fail early + // (instead of in teardown). + notStrictEqual( expando, undefined, "Target for expectJqData must have an expando, for else there can be no data to expect." ); } else { - expectedDataKeys[expando] = [ key ]; + if ( expectedDataKeys[expando] ) { + expectedDataKeys[expando].push( key ); + } else { + expectedDataKeys[expando] = [ key ]; + } } } } + }; QUnit.config.urlConfig.push( { id: "jqdata", @@ -258,33 +262,38 @@ var Globals = (function() { fragmentsLength = 0, cacheLength = 0; - // Only look for jQuery data problems if this test actually - // provided some information to compare against. - if ( QUnit.urlParams.jqdata || this.checkJqData ) { - for ( i in jQuery.cache ) { - expectedKeys = expectedDataKeys[i]; - actualKeys = jQuery.cache[i] ? keys( jQuery.cache[i] ) : jQuery.cache[i]; - if ( !QUnit.equiv( expectedKeys, actualKeys ) ) { - deepEqual( actualKeys, expectedKeys, "Expected keys exist in jQuery.cache" ); + if ( jQuery.cache ) { + // Only look for jQuery data problems if this test actually + // provided some information to compare against. + if ( QUnit.urlParams.jqdata || this.checkJqData ) { + for ( i in jQuery.cache ) { + expectedKeys = expectedDataKeys[i]; + actualKeys = jQuery.cache[i] ? keys( jQuery.cache[i] ) : jQuery.cache[i]; + if ( !QUnit.equiv( expectedKeys, actualKeys ) ) { + deepEqual( actualKeys, expectedKeys, "Expected keys exist in jQuery.cache" ); + } + delete jQuery.cache[i]; + delete expectedDataKeys[i]; + } + // In case it was removed from cache before (or never there in the first place) + for ( i in expectedDataKeys ) { + deepEqual( expectedDataKeys[i], undefined, "No unexpected keys were left in jQuery.cache (#" + i + ")" ); + delete expectedDataKeys[i]; } - delete jQuery.cache[i]; - delete expectedDataKeys[i]; - } - // In case it was removed from cache before (or never there in the first place) - for ( i in expectedDataKeys ) { - deepEqual( expectedDataKeys[i], undefined, "No unexpected keys were left in jQuery.cache (#" + i + ")" ); - delete expectedDataKeys[i]; } + + // Reset data register + expectedDataKeys = {}; } - // Reset data register - expectedDataKeys = {}; // Allow QUnit.reset to clean up any attached elements before checking for leaks QUnit.reset(); - for ( i in jQuery.cache ) { - ++cacheLength; + if ( jQuery.cache ) { + for ( i in jQuery.cache ) { + ++cacheLength; + } } jQuery.fragments = {}; @@ -334,7 +343,7 @@ var Globals = (function() { } else { delete jQuery.ajaxSettings; } - + // Cleanup globals Globals.cleanup(); diff --git a/test/unit/data.js b/test/unit/data.js index c09149b65..c4eca1660 100644 --- a/test/unit/data.js +++ b/test/unit/data.js @@ -1,11 +1,38 @@ -module("data", { teardown: moduleTeardown }); +module( "data", { teardown: moduleTeardown }); -test("expando", function(){ +test( "expando", function() { expect(1); equal(jQuery.expando !== undefined, true, "jQuery is exposing the expando"); }); +test( "jQuery.data & removeData, expected returns", function() { + expect(2); + + equal( + jQuery.data( document.body, "hello", "world" ), "world", + "jjQuery.data( elem, key, value ) returns value" + ); + equal( + jQuery.removeData( document.body, "hello" ), undefined, + "jjQuery.removeData( elem, key, value ) returns undefined" + ); + +}); + +test( "jQuery._data & _removeData, expected returns", function() { + expect(2); + + equal( + jQuery._data( document.body, "hello", "world" ), "world", + "jjQuery.data( elem, key, value ) returns value" + ); + equal( + jQuery._removeData( document.body, "hello" ), undefined, + "jjQuery.removeData( elem, key, value ) returns undefined" + ); +}); + function dataTests (elem) { var oldCacheLength, dataObj, internalDataObj, expected, actual; @@ -99,6 +126,7 @@ test("jQuery.data(document)", 25, function() { QUnit.expectJqData(document, "foo"); }); +/* test("Expando cleanup", 4, function() { var expected, actual, div = document.createElement("div"); @@ -132,7 +160,8 @@ test("Expando cleanup", 4, function() { // Clean up unattached element jQuery(div).remove(); }); - +*/ +/* test("jQuery.acceptData", function() { expect(7); @@ -150,7 +179,7 @@ test("jQuery.acceptData", function() { applet.setAttribute("classid", "clsid:8AD9C840-044E-11D1-B3E9-00805F499D93"); ok( !jQuery.acceptData( applet ), "applet" ); }); - +*/ test(".data()", function() { expect(5); @@ -465,8 +494,8 @@ test("jQuery.data should follow html5 specification regarding camel casing", fun div.data("foo-bar", "d"); - equal( div.data("fooBar"), "d", "Verify updated data-* key" ); - equal( div.data("foo-bar"), "d", "Verify updated data-* key" ); + equal( div.data("fooBar"), "d", "Verify updated data-* key (fooBar)" ); + equal( div.data("foo-bar"), "d", "Verify updated data-* key (foo-bar)" ); div.remove(); });