resources/jquery/jquery.mwExtension.js

   1 /*
   2  * JavaScript backwards-compatibility alternatives and other convenience functions
   3  */
   4 ( function ( $ ) {
   5
   6         $.extend({
   7                 trimLeft: function ( str ) {
   8                         return str === null ? '' : str.toString().replace( /^\s+/, '' );
   9                 },
  10                 trimRight: function ( str ) {
  11                         return str === null ?
  12                                         '' : str.toString().replace( /\s+$/, '' );
  13                 },
  14                 ucFirst: function ( str ) {
  15                         return str.charAt( 0 ).toUpperCase() + str.substr( 1 );
  16                 },
  17                 escapeRE: function ( str ) {
  18                         return str.replace ( /([\\{}()|.?*+\-\^$\[\]])/g, "\\$1" );
  19                 },
  20                 isDomElement: function ( el ) {
  21                         return !!el && !!el.nodeType;
  22                 },
  23                 isEmpty: function ( v ) {
  24                         if ( v === '' || v === 0 || v === '0' || v === null
  25                                 || v === false || v === undefined )
  26                         {
  27                                 return true;
  28                         }
  29                         // the for-loop could potentially contain prototypes
  30                         // to avoid that we check it's length first
  31                         if ( v.length === 0 ) {
  32                                 return true;
  33                         }
  34                         if ( typeof v === 'object' ) {
  35                                 for ( var key in v ) {
  36                                         return false;
  37                                 }
  38                                 return true;
  39                         }
  40                         return false;
  41                 },
  42                 compareArray: function ( arrThis, arrAgainst ) {
  43                         if ( arrThis.length !== arrAgainst.length ) {
  44                                 return false;
  45                         }
  46                         for ( var i = 0; i < arrThis.length; i++ ) {
  47                                 if ( $.isArray( arrThis[i] ) ) {
  48                                         if ( !$.compareArray( arrThis[i], arrAgainst[i] ) ) {
  49                                                 return false;
  50                                         }
  51                                 } else if ( arrThis[i] !== arrAgainst[i] ) {
  52                                         return false;
  53                                 }
  54                         }
  55                         return true;
  56                 },
  57                 compareObject: function ( objectA, objectB ) {
  58                         var prop, type;
  59
  60                         // Do a simple check if the types match
  61                         if ( typeof objectA === typeof objectB ) {
  62
  63                                 // Only loop over the contents if it really is an object
  64                                 if ( typeof objectA === 'object' ) {
  65                                         // If they are aliases of the same object (ie. mw and mediaWiki) return now
  66                                         if ( objectA === objectB ) {
  67                                                 return true;
  68                                         } else {
  69                                                 // Iterate over each property
  70                                                 for ( prop in objectA ) {
  71                                                         // Check if this property is also present in the other object
  72                                                         if ( prop in objectB ) {
  73                                                                 // Compare the types of the properties
  74                                                                 type = typeof objectA[prop];
  75                                                                 if ( type === typeof objectB[prop] ) {
  76                                                                         // Recursively check objects inside this one
  77                                                                         switch ( type ) {
  78                                                                                 case 'object' :
  79                                                                                         if ( !$.compareObject( objectA[prop], objectB[prop] ) ) {
  80                                                                                                 return false;
  81                                                                                         }
  82                                                                                         break;
  83                                                                                 case 'function' :
  84                                                                                         // Functions need to be strings to compare them properly
  85                                                                                         if ( objectA[prop].toString() !== objectB[prop].toString() ) {
  86                                                                                                 return false;
  87                                                                                         }
  88                                                                                         break;
  89                                                                                 default:
  90                                                                                         // Strings, numbers
  91                                                                                         if ( objectA[prop] !== objectB[prop] ) {
  92                                                                                                 return false;
  93                                                                                         }
  94                                                                                         break;
  95                                                                         }
  96                                                                 } else {
  97                                                                         return false;
  98                                                                 }
  99                                                         } else {
 100                                                                 return false;
 101                                                         }
 102                                                 }
 103                                                 // Check for properties in B but not in A
 104                                                 // This is about 15% faster (tested in Safari 5 and Firefox 3.6)
 105                                                 // ...than incrementing a count variable in the above and below loops
 106                                                 // See also: http://www.mediawiki.org/wiki/ResourceLoader/Default_modules/compareObject_test#Results
 107                                                 for ( prop in objectB ) {
 108                                                         if ( !( prop in objectA ) ) {
 109                                                                 return false;
 110                                                         }
 111                                                 }
 112                                         }
 113                                 }
 114                         } else {
 115                                 return false;
 116                         }
 117                         return true;
 118                 }
 119         });
 120
 121 }( jQuery ) );