Moved unload abort code so that the event is only bound if the xhr transport is used...
[jquery.git] / src / data.js
index 3e6eb19..4d1d1bd 100644 (file)
@@ -1,53 +1,98 @@
-var expando = "jQuery" + now(), uuid = 0, windowData = {};
-var emptyObject = {};
+(function( jQuery ) {
+
+var windowData = {},
+       rbrace = /^(?:\{.*\}|\[.*\])$/;
 
 jQuery.extend({
        cache: {},
-       
-       expando:expando,
+
+       // Please use with caution
+       uuid: 0,
+
+       // Unique for each copy of jQuery on the page
+       // Non-digits removed to match rinlinejQuery
+       expando: "jQuery" + ( jQuery.fn.jquery + 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 ) {
+               if ( elem.nodeType ) {
+                       elem = jQuery.cache[ elem[jQuery.expando] ];
+               }
+
+               return !!elem && !jQuery.isEmptyObject(elem);
+       },
 
        data: function( elem, name, data ) {
+               if ( !jQuery.acceptData( elem ) ) {
+                       return;
+               }
+
                elem = elem == window ?
                        windowData :
                        elem;
 
-               var id = elem[ expando ], cache = jQuery.cache, thisCache;
+               var isNode = elem.nodeType,
+                       id = isNode ? elem[ jQuery.expando ] : null,
+                       cache = jQuery.cache, thisCache;
 
-               // Handle the case where there's no name immediately
-               if ( !name && !id ) {
-                       return null;
+               if ( isNode && !id && typeof name === "string" && data === undefined ) {
+                       return;
                }
 
+               // Get the data from the object directly
+               if ( !isNode ) {
+                       cache = elem;
+
                // Compute a unique ID for the element
-               if ( !id ) { 
-                       id = ++uuid;
+               } else if ( !id ) {
+                       elem[ jQuery.expando ] = id = ++jQuery.uuid;
                }
 
                // Avoid generating a new cache unless none exists and we
                // want to manipulate it.
-               if ( cache[ id ] ) {
-                       thisCache = cache[ id ];
-               } else if ( typeof data === "undefined" ) {
-                       thisCache = emptyObject;
-               } else {
-                       thisCache = cache[ id ] = {};
+               if ( typeof name === "object" ) {
+                       if ( isNode ) {
+                               cache[ id ] = jQuery.extend(cache[ id ], name);
+
+                       } else {
+                               jQuery.extend( cache, name );
+                       }
+
+               } else if ( isNode && !cache[ id ] ) {
+                       cache[ id ] = {};
                }
-               
+
+               thisCache = isNode ? cache[ id ] : cache;
+
                // Prevent overriding the named cache with undefined values
                if ( data !== undefined ) {
-                       elem[ expando ] = id;
                        thisCache[ name ] = data;
                }
-               
-               return name ? thisCache[ name ] : thisCache;
+
+               return typeof name === "string" ? thisCache[ name ] : thisCache;
        },
 
        removeData: function( elem, name ) {
+               if ( !jQuery.acceptData( elem ) ) {
+                       return;
+               }
+
                elem = elem == window ?
                        windowData :
                        elem;
 
-               var id = elem[ expando ], cache = jQuery.cache, thisCache = cache[ id ];
+               var isNode = elem.nodeType,
+                       id = isNode ? elem[ jQuery.expando ] : elem,
+                       cache = jQuery.cache,
+                       thisCache = isNode ? cache[ id ] : id;
 
                // If we want to remove a specific section of the element's data
                if ( name ) {
@@ -56,132 +101,135 @@ jQuery.extend({
                                delete thisCache[ name ];
 
                                // If we've removed all the data, remove the element's cache
-                               if ( jQuery.isEmptyObject(thisCache) ) {
+                               if ( isNode && jQuery.isEmptyObject(thisCache) ) {
                                        jQuery.removeData( elem );
                                }
                        }
 
                // Otherwise, we want to remove all of the element's data
                } else {
-                       // Clean up the element expando
-                       try {
-                               delete elem[ expando ];
-                       } catch( e ) {
-                               // IE has trouble directly removing the expando
-                               // but it's ok with using removeAttribute
-                               if ( elem.removeAttribute ) {
-                                       elem.removeAttribute( expando );
-                               }
-                       }
+                       if ( isNode && jQuery.support.deleteExpando ) {
+                               delete elem[ jQuery.expando ];
 
-                       // Completely remove the data cache
-                       delete cache[ id ];
-               }
-       },
-       
-       queue: function( elem, type, data ) {
-               if ( !elem ) { return; }
-
-               type = (type || "fx") + "queue";
-               var q = jQuery.data( elem, type );
+                       } else if ( elem.removeAttribute ) {
+                               elem.removeAttribute( jQuery.expando );
 
-               // Speed up dequeue by getting out quickly if this is just a lookup
-               if ( !data ) { return q || []; }
+                       // Completely remove the data cache
+                       } else if ( isNode ) {
+                               delete cache[ id ];
 
-               if ( !q || jQuery.isArray(data) ) {
-                       q = jQuery.data( elem, type, jQuery.makeArray(data) );
-               } else {
-                       q.push( data );
+                       // Remove all fields from the object
+                       } else {
+                               for ( var n in elem ) {
+                                       delete elem[ n ];
+                               }
+                       }
                }
-               return q;
        },
 
-       dequeue: function( elem, type ){
-               type = type || "fx";
+       // A method for determining if a DOM node can handle the data expando
+       acceptData: function( elem ) {
+               if ( elem.nodeName ) {
+                       var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
 
-               var queue = jQuery.queue( elem, type ), fn = queue.shift();
-
-               // If the fx queue is dequeued, always remove the progress sentinel
-               if ( fn === "inprogress" ) { fn = queue.shift(); }
-
-               if ( fn ) {
-                       // Add a progress sentinel to prevent the fx queue from being
-                       // automatically dequeued
-                       if ( type == "fx" ) { queue.unshift("inprogress"); }
-
-                       fn.call(elem, function() { jQuery.dequeue(elem, type); });
+                       if ( match ) {
+                               return !(match === true || elem.getAttribute("classid") !== match);
+                       }
                }
+
+               return true;
        }
 });
 
 jQuery.fn.extend({
-       data: function( key, value ){
-               if ( typeof key === "undefined" && this.length ) {
-                       return jQuery.data( this[0] );
+       data: function( key, value ) {
+               var data = null;
+
+               if ( typeof key === "undefined" ) {
+                       if ( this.length ) {
+                               data = jQuery.data( this[0] );
+
+                               if ( this[0].nodeType === 1 ) {
+                                       var attr = this[0].attributes, name;
+                                       for ( var i = 0, l = attr.length; i < l; i++ ) {
+                                               name = attr[i].name;
+
+                                               if ( name.indexOf( "data-" ) === 0 ) {
+                                                       name = name.substr( 5 );
+                                                       dataAttr( this[0], name, data[ name ] );
+                                               }
+                                       }
+                               }
+                       }
+
+                       return data;
+
+               } else if ( typeof key === "object" ) {
+                       return this.each(function() {
+                               jQuery.data( this, key );
+                       });
                }
 
                var parts = key.split(".");
                parts[1] = parts[1] ? "." + parts[1] : "";
 
                if ( value === undefined ) {
-                       var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
+                       data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
 
+                       // Try to fetch any internally stored data first
                        if ( data === undefined && this.length ) {
                                data = jQuery.data( this[0], key );
+                               data = dataAttr( this[0], key, data );
                        }
+
                        return data === undefined && parts[1] ?
                                this.data( parts[0] ) :
                                data;
+
                } else {
-                       return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
+                       return this.each(function() {
+                               var $this = jQuery( this ),
+                                       args = [ parts[0], value ];
+
+                               $this.triggerHandler( "setData" + parts[1] + "!", args );
                                jQuery.data( this, key, value );
+                               $this.triggerHandler( "changeData" + parts[1] + "!", args );
                        });
                }
        },
 
-       removeData: function( key ){
-               return this.each(function(){
+       removeData: function( key ) {
+               return this.each(function() {
                        jQuery.removeData( this, key );
                });
-       },
-       queue: function(type, data){
-               if ( typeof type !== "string" ) {
-                       data = type;
-                       type = "fx";
-               }
+       }
+});
 
-               if ( data === undefined ) {
-                       return jQuery.queue( this[0], type );
-               }
-               return this.each(function(i, elem){
-                       var queue = jQuery.queue( this, type, data );
+function dataAttr( elem, key, data ) {
+       // If nothing was found internally, try to fetch any
+       // data from the HTML5 data-* attribute
+       if ( data === undefined && elem.nodeType === 1 ) {
+               data = elem.getAttribute( "data-" + key );
 
-                       if ( type == "fx" && queue[0] !== "inprogress" ) {
-                               jQuery.dequeue( this, type );
-                       }
-               });
-       },
-       dequeue: function(type){
-               return this.each(function(){
-                       jQuery.dequeue( this, type );
-               });
-       },
+               if ( typeof data === "string" ) {
+                       try {
+                               data = data === "true" ? true :
+                               data === "false" ? false :
+                               data === "null" ? null :
+                               !jQuery.isNaN( data ) ? parseFloat( data ) :
+                                       rbrace.test( data ) ? jQuery.parseJSON( data ) :
+                                       data;
+                       } catch( e ) {}
 
-       // Based off of the plugin by Clint Helfers, with permission.
-       // http://blindsignals.com/index.php/2009/07/jquery-delay/
-       delay: function( time, type ) {
-               time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
-               type = type || "fx";
-
-               return this.queue( type, function() {
-                       var elem = this;
-                       setTimeout(function() {
-                               jQuery.dequeue( elem, type );
-                       }, time );
-               });
-       },
+                       // Make sure we set the data so it isn't changed later
+                       jQuery.data( elem, key, data );
 
-       clearQueue: function(type){
-               return this.queue( type || "fx", [] );
+               } else {
+                       data = undefined;
+               }
        }
-});
+
+       return data;
+}
+
+})( jQuery );