resources/jquery/jquery.tablesorter.js

   1 /**
   2  * TableSorter for MediaWiki
   3  *
   4  * Written 2011 Leo Koppelkamm
   5  * Based on tablesorter.com plugin, written (c) 2007 Christian Bach.
   6  *
   7  * Dual licensed under the MIT and GPL licenses:
   8  * http://www.opensource.org/licenses/mit-license.php
   9  * http://www.gnu.org/licenses/gpl.html
  10  *
  11  * Depends on mw.config (wgDigitTransformTable, wgMonthNames, wgMonthNamesShort,
  12  * wgDefaultDateFormat, wgContentLanguage)
  13  * Uses 'tableSorterCollation' in mw.config (if available)
  14  */
  15 /**
  16  *
  17  * @description Create a sortable table with multi-column sorting capabilitys
  18  *
  19  * @example $( 'table' ).tablesorter();
  20  * @desc Create a simple tablesorter interface.
  21  *
  22  * @example $( 'table' ).tablesorter( { sortList: [ { 0: 'desc' }, { 1: 'asc' } ] } );
  23  * @desc Create a tablesorter interface initially sorting on the first and second column.
  24  *
  25  * @option String cssHeader ( optional ) A string of the class name to be appended
  26  *         to sortable tr elements in the thead of the table. Default value:
  27  *         "header"
  28  *
  29  * @option String cssAsc ( optional ) A string of the class name to be appended to
  30  *         sortable tr elements in the thead on a ascending sort. Default value:
  31  *         "headerSortUp"
  32  *
  33  * @option String cssDesc ( optional ) A string of the class name to be appended
  34  *         to sortable tr elements in the thead on a descending sort. Default
  35  *         value: "headerSortDown"
  36  *
  37  * @option String sortInitialOrder ( optional ) A string of the inital sorting
  38  *         order can be asc or desc. Default value: "asc"
  39  *
  40  * @option String sortMultisortKey ( optional ) A string of the multi-column sort
  41  *         key. Default value: "shiftKey"
  42  *
  43  * @option Boolean sortLocaleCompare ( optional ) Boolean flag indicating whatever
  44  *         to use String.localeCampare method or not. Set to false.
  45  *
  46  * @option Boolean cancelSelection ( optional ) Boolean flag indicating if
  47  *         tablesorter should cancel selection of the table headers text.
  48  *         Default value: true
  49  *
  50  * @option Array sortList ( optional ) An array containing objects specifying sorting.
  51  *         By passing more than one object, multi-sorting will be applied. Object structure:
  52  *         { <Integer column index>: <String 'asc' or 'desc'> }
  53  *         Default value: []
  54  *
  55  * @option Boolean debug ( optional ) Boolean flag indicating if tablesorter
  56  *         should display debuging information usefull for development.
  57  *
  58  * @event sortEnd.tablesorter: Triggered as soon as any sorting has been applied.
  59  *
  60  * @type jQuery
  61  *
  62  * @name tablesorter
  63  *
  64  * @cat Plugins/Tablesorter
  65  *
  66  * @author Christian Bach/christian.bach@polyester.se
  67  */
  68
  69 ( function ( $, mw ) {
  70         /*jshint onevar:false */
  71
  72         /* Local scope */
  73
  74         var ts,
  75                 parsers = [];
  76
  77         /* Parser utility functions */
  78
  79         function getParserById( name ) {
  80                 var len = parsers.length;
  81                 for ( var i = 0; i < len; i++ ) {
  82                         if ( parsers[i].id.toLowerCase() === name.toLowerCase() ) {
  83                                 return parsers[i];
  84                         }
  85                 }
  86                 return false;
  87         }
  88
  89         function getElementSortKey( node ) {
  90                 var $node = $( node ),
  91                         // Use data-sort-value attribute.
  92                         // Use data() instead of attr() so that live value changes
  93                         // are processed as well (bug 38152).
  94                         data = $node.data( 'sortValue' );
  95
  96                 if ( data !== null && data !== undefined ) {
  97                         // Cast any numbers or other stuff to a string, methods
  98                         // like charAt, toLowerCase and split are expected.
  99                         return String( data );
 100                 } else {
 101                         if ( !node ) {
 102                                 return $node.text();
 103                         } else if ( node.tagName.toLowerCase() === 'img' ) {
 104                                 return $node.attr( 'alt' ) || ''; // handle undefined alt
 105                         } else {
 106                                 return $.map( $.makeArray( node.childNodes ), function( elem ) {
 107                                         // 1 is for document.ELEMENT_NODE (the constant is undefined on old browsers)
 108                                         if ( elem.nodeType === 1 ) {
 109                                                 return getElementSortKey( elem );
 110                                         } else {
 111                                                 return $.text( elem );
 112                                         }
 113                                 } ).join( '' );
 114                         }
 115                 }
 116         }
 117
 118         function detectParserForColumn( table, rows, cellIndex ) {
 119                 var l = parsers.length,
 120                         nodeValue,
 121                         // Start with 1 because 0 is the fallback parser
 122                         i = 1,
 123                         rowIndex = 0,
 124                         concurrent = 0,
 125                         needed = ( rows.length > 4 ) ? 5 : rows.length;
 126
 127                 while ( i < l ) {
 128                         if ( rows[rowIndex] && rows[rowIndex].cells[cellIndex] ) {
 129                                 nodeValue = $.trim( getElementSortKey( rows[rowIndex].cells[cellIndex] ) );
 130                         } else {
 131                                 nodeValue = '';
 132                         }
 133
 134                         if ( nodeValue !== '') {
 135                                 if ( parsers[i].is( nodeValue, table ) ) {
 136                                         concurrent++;
 137                                         rowIndex++;
 138                                         if ( concurrent >= needed ) {
 139                                                 // Confirmed the parser for multiple cells, let's return it
 140                                                 return parsers[i];
 141                                         }
 142                                 } else {
 143                                         // Check next parser, reset rows
 144                                         i++;
 145                                         rowIndex = 0;
 146                                         concurrent = 0;
 147                                 }
 148                         } else {
 149                                 // Empty cell
 150                                 rowIndex++;
 151                                 if ( rowIndex > rows.length ) {
 152                                         rowIndex = 0;
 153                                         i++;
 154                                 }
 155                         }
 156                 }
 157
 158                 // 0 is always the generic parser (text)
 159                 return parsers[0];
 160         }
 161
 162         function buildParserCache( table, $headers ) {
 163                 var rows = table.tBodies[0].rows,
 164                         sortType,
 165                         parsers = [];
 166
 167                 if ( rows[0] ) {
 168
 169                         var cells = rows[0].cells,
 170                                 len = cells.length,
 171                                 i, parser;
 172
 173                         for ( i = 0; i < len; i++ ) {
 174                                 parser = false;
 175                                 sortType = $headers.eq( i ).data( 'sortType' );
 176                                 if ( sortType !== undefined ) {
 177                                         parser = getParserById( sortType );
 178                                 }
 179
 180                                 if ( parser === false ) {
 181                                         parser = detectParserForColumn( table, rows, i );
 182                                 }
 183
 184                                 parsers.push( parser );
 185                         }
 186                 }
 187                 return parsers;
 188         }
 189
 190         /* Other utility functions */
 191
 192         function buildCache( table ) {
 193                 var totalRows = ( table.tBodies[0] && table.tBodies[0].rows.length ) || 0,
 194                         totalCells = ( table.tBodies[0].rows[0] && table.tBodies[0].rows[0].cells.length ) || 0,
 195                         parsers = table.config.parsers,
 196                         cache = {
 197                                 row: [],
 198                                 normalized: []
 199                         };
 200
 201                 for ( var i = 0; i < totalRows; ++i ) {
 202
 203                         // Add the table data to main data array
 204                         var $row = $( table.tBodies[0].rows[i] ),
 205                                 cols = [];
 206
 207                         // if this is a child row, add it to the last row's children and
 208                         // continue to the next row
 209                         if ( $row.hasClass( table.config.cssChildRow ) ) {
 210                                 cache.row[cache.row.length - 1] = cache.row[cache.row.length - 1].add( $row );
 211                                 // go to the next for loop
 212                                 continue;
 213                         }
 214
 215                         cache.row.push( $row );
 216
 217                         for ( var j = 0; j < totalCells; ++j ) {
 218                                 cols.push( parsers[j].format( getElementSortKey( $row[0].cells[j] ), table, $row[0].cells[j] ) );
 219                         }
 220
 221                         cols.push( cache.normalized.length ); // add position for rowCache
 222                         cache.normalized.push( cols );
 223                         cols = null;
 224                 }
 225
 226                 return cache;
 227         }
 228
 229         function appendToTable( table, cache ) {
 230                 var row = cache.row,
 231                         normalized = cache.normalized,
 232                         totalRows = normalized.length,
 233                         checkCell = ( normalized[0].length - 1 ),
 234                         fragment = document.createDocumentFragment();
 235
 236                 for ( var i = 0; i < totalRows; i++ ) {
 237                         var pos = normalized[i][checkCell];
 238
 239                         var l = row[pos].length;
 240
 241                         for ( var j = 0; j < l; j++ ) {
 242                                 fragment.appendChild( row[pos][j] );
 243                         }
 244
 245                 }
 246                 table.tBodies[0].appendChild( fragment );
 247
 248                 $( table ).trigger( 'sortEnd.tablesorter' );
 249         }
 250
 251         /**
 252          * Find all header rows in a thead-less table and put them in a <thead> tag.
 253          * This only treats a row as a header row if it contains only <th>s (no <td>s)
 254          * and if it is preceded entirely by header rows. The algorithm stops when
 255          * it encounters the first non-header row.
 256          *
 257          * After this, it will look at all rows at the bottom for footer rows
 258          * And place these in a tfoot using similar rules.
 259          * @param $table jQuery object for a <table>
 260          */
 261         function emulateTHeadAndFoot( $table ) {
 262                 var $rows = $table.find( '> tbody > tr' );
 263                 if( !$table.get(0).tHead ) {
 264                         var $thead = $( '<thead>' );
 265                         $rows.each( function () {
 266                                 if ( $(this).children( 'td' ).length > 0 ) {
 267                                         // This row contains a <td>, so it's not a header row
 268                                         // Stop here
 269                                         return false;
 270                                 }
 271                                 $thead.append( this );
 272                         } );
 273                         $table.find(' > tbody:first').before( $thead );
 274                 }
 275                 if( !$table.get(0).tFoot ) {
 276                         var $tfoot = $( '<tfoot>' );
 277                         var len = $rows.length;
 278                         for ( var i = len-1; i >= 0; i-- ) {
 279                                 if( $( $rows[i] ).children( 'td' ).length > 0 ){
 280                                         break;
 281                                 }
 282                                 $tfoot.prepend( $( $rows[i] ));
 283                         }
 284                         $table.append( $tfoot );
 285                 }
 286         }
 287
 288         function buildHeaders( table, msg ) {
 289                 var maxSeen = 0,
 290                         longest,
 291                         realCellIndex = 0,
 292                         $tableHeaders = $( 'thead:eq(0) > tr', table );
 293                 if ( $tableHeaders.length > 1 ) {
 294                         $tableHeaders.each( function () {
 295                                 if ( this.cells.length > maxSeen ) {
 296                                         maxSeen = this.cells.length;
 297                                         longest = this;
 298                                 }
 299                         });
 300                         $tableHeaders = $( longest );
 301                 }
 302                 $tableHeaders = $tableHeaders.children( 'th' ).each( function ( index ) {
 303                         this.column = realCellIndex;
 304
 305                         var colspan = this.colspan;
 306                         colspan = colspan ? parseInt( colspan, 10 ) : 1;
 307                         realCellIndex += colspan;
 308
 309                         this.order = 0;
 310                         this.count = 0;
 311
 312                         if ( $( this ).is( '.unsortable' ) ) {
 313                                 this.sortDisabled = true;
 314                         }
 315
 316                         if ( !this.sortDisabled ) {
 317                                 $( this ).addClass( table.config.cssHeader ).attr( 'title', msg[1] );
 318                         }
 319
 320                         // add cell to headerList
 321                         table.config.headerList[index] = this;
 322                 } );
 323
 324                 return $tableHeaders;
 325
 326         }
 327
 328         function isValueInArray( v, a ) {
 329                 var l = a.length;
 330                 for ( var i = 0; i < l; i++ ) {
 331                         if ( a[i][0] === v ) {
 332                                 return true;
 333                         }
 334                 }
 335                 return false;
 336         }
 337
 338         function setHeadersCss( table, $headers, list, css, msg, columnToHeader ) {
 339                 // Remove all header information and reset titles to default message
 340                 $headers.removeClass( css[0] ).removeClass( css[1] ).attr( 'title', msg[1] );
 341
 342                 for ( var i = 0; i < list.length; i++ ) {
 343                         $headers.eq( columnToHeader[ list[i][0] ] )
 344                                 .addClass( css[ list[i][1] ] )
 345                                 .attr( 'title', msg[ list[i][1] ] );
 346                 }
 347         }
 348
 349         function sortText( a, b ) {
 350                 return ( (a < b) ? -1 : ((a > b) ? 1 : 0) );
 351         }
 352
 353         function sortTextDesc( a, b ) {
 354                 return ( (b < a) ? -1 : ((b > a) ? 1 : 0) );
 355         }
 356
 357         function multisort( table, sortList, cache ) {
 358                 var sortFn = [];
 359                 var len = sortList.length;
 360                 for ( var i = 0; i < len; i++ ) {
 361                         sortFn[i] = ( sortList[i][1] ) ? sortTextDesc : sortText;
 362                 }
 363                 cache.normalized.sort( function ( array1, array2 ) {
 364                         var col, ret;
 365                         for ( var i = 0; i < len; i++ ) {
 366                                 col = sortList[i][0];
 367                                 ret = sortFn[i].call( this, array1[col], array2[col] );
 368                                 if ( ret !== 0 ) {
 369                                         return ret;
 370                                 }
 371                         }
 372                         // Fall back to index number column to ensure stable sort
 373                         return sortText.call( this, array1[array1.length - 1], array2[array2.length - 1] );
 374                 } );
 375                 return cache;
 376         }
 377
 378         function buildTransformTable() {
 379                 var digits = '0123456789,.'.split( '' );
 380                 var separatorTransformTable = mw.config.get( 'wgSeparatorTransformTable' );
 381                 var digitTransformTable = mw.config.get( 'wgDigitTransformTable' );
 382                 if ( separatorTransformTable === null || ( separatorTransformTable[0] === '' && digitTransformTable[2] === '' ) ) {
 383                         ts.transformTable = false;
 384                 } else {
 385                         ts.transformTable = {};
 386
 387                         // Unpack the transform table
 388                         var ascii = separatorTransformTable[0].split( '\t' ).concat( digitTransformTable[0].split( '\t' ) );
 389                         var localised = separatorTransformTable[1].split( '\t' ).concat( digitTransformTable[1].split( '\t' ) );
 390
 391                         // Construct regex for number identification
 392                         for ( var i = 0; i < ascii.length; i++ ) {
 393                                 ts.transformTable[localised[i]] = ascii[i];
 394                                 digits.push( $.escapeRE( localised[i] ) );
 395                         }
 396                 }
 397                 var digitClass = '[' + digits.join( '', digits ) + ']';
 398
 399                 // We allow a trailing percent sign, which we just strip. This works fine
 400                 // if percents and regular numbers aren't being mixed.
 401                 ts.numberRegex = new RegExp('^(' + '[-+\u2212]?[0-9][0-9,]*(\\.[0-9,]*)?(E[-+\u2212]?[0-9][0-9,]*)?' + // Fortran-style scientific
 402                 '|' + '[-+\u2212]?' + digitClass + '+[\\s\\xa0]*%?' + // Generic localised
 403                 ')$', 'i');
 404         }
 405
 406         function buildDateTable() {
 407                 var regex = [];
 408                 ts.monthNames = {};
 409
 410                 for ( var i = 1; i < 13; i++ ) {
 411                         var name = mw.config.get( 'wgMonthNames' )[i].toLowerCase();
 412                         ts.monthNames[name] = i;
 413                         regex.push( $.escapeRE( name ) );
 414                         name = mw.config.get( 'wgMonthNamesShort' )[i].toLowerCase().replace( '.', '' );
 415                         ts.monthNames[name] = i;
 416                         regex.push( $.escapeRE( name ) );
 417                 }
 418
 419                 // Build piped string
 420                 regex = regex.join( '|' );
 421
 422                 // Build RegEx
 423                 // Any date formated with . , ' - or /
 424                 ts.dateRegex[0] = new RegExp( /^\s*(\d{1,2})[\,\.\-\/'\s]{1,2}(\d{1,2})[\,\.\-\/'\s]{1,2}(\d{2,4})\s*?/i);
 425
 426                 // Written Month name, dmy
 427                 ts.dateRegex[1] = new RegExp( '^\\s*(\\d{1,2})[\\,\\.\\-\\/\'\\s]*(' + regex + ')' + '[\\,\\.\\-\\/\'\\s]*(\\d{2,4})\\s*$', 'i' );
 428
 429                 // Written Month name, mdy
 430                 ts.dateRegex[2] = new RegExp( '^\\s*(' + regex + ')' + '[\\,\\.\\-\\/\'\\s]*(\\d{1,2})[\\,\\.\\-\\/\'\\s]*(\\d{2,4})\\s*$', 'i' );
 431
 432         }
 433
 434         function explodeRowspans( $table ) {
 435                 // Split multi row cells into multiple cells with the same content
 436                 $table.find( '> tbody > tr > [rowspan]' ).each(function () {
 437                         var rowSpan = this.rowSpan;
 438                         this.rowSpan = 1;
 439                         var cell = $( this );
 440                         var next = cell.parent().nextAll();
 441                         for ( var i = 0; i < rowSpan - 1; i++ ) {
 442                                 var td = next.eq( i ).children( 'td' );
 443                                 if ( !td.length ) {
 444                                         next.eq( i ).append( cell.clone() );
 445                                 } else if ( this.cellIndex === 0 ) {
 446                                         td.eq( this.cellIndex ).before( cell.clone() );
 447                                 } else {
 448                                         td.eq( this.cellIndex - 1 ).after( cell.clone() );
 449                                 }
 450                         }
 451                 });
 452         }
 453
 454         function buildCollationTable() {
 455                 ts.collationTable = mw.config.get( 'tableSorterCollation' );
 456                 ts.collationRegex = null;
 457                 if ( ts.collationTable ) {
 458                         var keys = [];
 459
 460                         // Build array of key names
 461                         for ( var key in ts.collationTable ) {
 462                                 if ( ts.collationTable.hasOwnProperty(key) ) { //to be safe
 463                                         keys.push(key);
 464                                 }
 465                         }
 466                         if (keys.length) {
 467                                 ts.collationRegex = new RegExp( '[' + keys.join( '' ) + ']', 'ig' );
 468                         }
 469                 }
 470         }
 471
 472         function cacheRegexs() {
 473                 if ( ts.rgx ) {
 474                         return;
 475                 }
 476                 ts.rgx = {
 477                         IPAddress: [
 478                                 new RegExp( /^\d{1,3}[\.]\d{1,3}[\.]\d{1,3}[\.]\d{1,3}$/)
 479                         ],
 480                         currency: [
 481                                 new RegExp( /(^[£$€¥]|[£$€¥]$)/),
 482                                 new RegExp( /[£$€¥]/g)
 483                         ],
 484                         url: [
 485                                 new RegExp( /^(https?|ftp|file):\/\/$/),
 486                                 new RegExp( /(https?|ftp|file):\/\//)
 487                         ],
 488                         isoDate: [
 489                                 new RegExp( /^\d{4}[\/\-]\d{1,2}[\/\-]\d{1,2}$/)
 490                         ],
 491                         usLongDate: [
 492                                 new RegExp( /^[A-Za-z]{3,10}\.? [0-9]{1,2}, ([0-9]{4}|'?[0-9]{2}) (([0-2]?[0-9]:[0-5][0-9])|([0-1]?[0-9]:[0-5][0-9]\s(AM|PM)))$/)
 493                         ],
 494                         time: [
 495                                 new RegExp( /^(([0-2]?[0-9]:[0-5][0-9])|([0-1]?[0-9]:[0-5][0-9]\s(am|pm)))$/)
 496                         ]
 497                 };
 498         }
 499
 500         /**
 501          * Converts sort objects [ { Integer: String }, ... ] to the internally used nested array
 502          * structure [ [ Integer , Integer ], ... ]
 503          *
 504          * @param sortObjects {Array} List of sort objects.
 505          * @return {Array} List of internal sort definitions.
 506          */
 507
 508         function convertSortList( sortObjects ) {
 509                 var sortList = [];
 510                 $.each( sortObjects, function( i, sortObject ) {
 511                         $.each ( sortObject, function( columnIndex, order ) {
 512                                 var orderIndex = ( order === 'desc' ) ? 1 : 0;
 513                                 sortList.push( [columnIndex, orderIndex] );
 514                         } );
 515                 } );
 516                 return sortList;
 517         }
 518
 519         /* Public scope */
 520
 521         $.tablesorter = {
 522
 523                         defaultOptions: {
 524                                 cssHeader: 'headerSort',
 525                                 cssAsc: 'headerSortUp',
 526                                 cssDesc: 'headerSortDown',
 527                                 cssChildRow: 'expand-child',
 528                                 sortInitialOrder: 'asc',
 529                                 sortMultiSortKey: 'shiftKey',
 530                                 sortLocaleCompare: false,
 531                                 parsers: {},
 532                                 widgets: [],
 533                                 headers: {},
 534                                 cancelSelection: true,
 535                                 sortList: [],
 536                                 headerList: [],
 537                                 selectorHeaders: 'thead tr:eq(0) th',
 538                                 debug: false
 539                         },
 540
 541                         dateRegex: [],
 542                         monthNames: {},
 543
 544                         /**
 545                          * @param $tables {jQuery}
 546                          * @param settings {Object} (optional)
 547                          */
 548                         construct: function ( $tables, settings ) {
 549                                 return $tables.each( function ( i, table ) {
 550                                         // Declare and cache.
 551                                         var $headers, cache, config,
 552                                                 headerToColumns, columnToHeader, colspanOffset,
 553                                                 $table = $( table ),
 554                                                 firstTime = true;
 555
 556                                         // Quit if no tbody
 557                                         if ( !table.tBodies ) {
 558                                                 return;
 559                                         }
 560                                         if ( !table.tHead ) {
 561                                                 // No thead found. Look for rows with <th>s and
 562                                                 // move them into a <thead> tag or a <tfoot> tag
 563                                                 emulateTHeadAndFoot( $table );
 564
 565                                                 // Still no thead? Then quit
 566                                                 if ( !table.tHead ) {
 567                                                         return;
 568                                                 }
 569                                         }
 570                                         $table.addClass( 'jquery-tablesorter' );
 571
 572                                         // FIXME config should probably not be stored in the plain table node
 573                                         // New config object.
 574                                         table.config = {};
 575
 576                                         // Merge and extend.
 577                                         config = $.extend( table.config, $.tablesorter.defaultOptions, settings );
 578
 579                                         // Save the settings where they read
 580                                         $.data( table, 'tablesorter', { config: config } );
 581
 582                                         // Get the CSS class names, could be done else where.
 583                                         var sortCSS = [ config.cssDesc, config.cssAsc ];
 584                                         var sortMsg = [ mw.msg( 'sort-descending' ), mw.msg( 'sort-ascending' ) ];
 585
 586                                         // Build headers
 587                                         $headers = buildHeaders( table, sortMsg );
 588
 589                                         // Grab and process locale settings
 590                                         buildTransformTable();
 591                                         buildDateTable();
 592                                         buildCollationTable();
 593
 594                                         // Precaching regexps can bring 10 fold
 595                                         // performance improvements in some browsers.
 596                                         cacheRegexs();
 597
 598                                         function setupForFirstSort() {
 599                                                 firstTime = false;
 600
 601                                                 // Legacy fix of .sortbottoms
 602                                                 // Wrap them inside inside a tfoot (because that's what they actually want to be) &
 603                                                 // and put the <tfoot> at the end of the <table>
 604                                                 var $sortbottoms = $table.find( '> tbody > tr.sortbottom' );
 605                                                 if ( $sortbottoms.length ) {
 606                                                         var $tfoot = $table.children( 'tfoot' );
 607                                                         if ( $tfoot.length ) {
 608                                                                 $tfoot.eq(0).prepend( $sortbottoms );
 609                                                         } else {
 610                                                                 $table.append( $( '<tfoot>' ).append( $sortbottoms ) );
 611                                                         }
 612                                                 }
 613
 614                                                 explodeRowspans( $table );
 615
 616                                                 // try to auto detect column type, and store in tables config
 617                                                 table.config.parsers = buildParserCache( table, $headers );
 618                                         }
 619
 620                                         // as each header can span over multiple columns (using colspan=N),
 621                                         // we have to bidirectionally map headers to their columns and columns to their headers
 622                                         headerToColumns = [];
 623                                         columnToHeader = [];
 624                                         colspanOffset = 0;
 625                                         $headers.each( function ( headerIndex ) {
 626                                                 var columns = [];
 627                                                 for ( var i = 0; i < this.colSpan; i++ ) {
 628                                                         columnToHeader[ colspanOffset + i ] = headerIndex;
 629                                                         columns.push( colspanOffset + i );
 630                                                 }
 631
 632                                                 headerToColumns[ headerIndex ] = columns;
 633                                                 colspanOffset += this.colSpan;
 634                                         } );
 635
 636                                         // Apply event handling to headers
 637                                         // this is too big, perhaps break it out?
 638                                         $headers.filter( ':not(.unsortable)' ).click( function ( e ) {
 639                                                 if ( e.target.nodeName.toLowerCase() === 'a' ) {
 640                                                         // The user clicked on a link inside a table header
 641                                                         // Do nothing and let the default link click action continue
 642                                                         return true;
 643                                                 }
 644
 645                                                 if ( firstTime ) {
 646                                                         setupForFirstSort();
 647                                                 }
 648
 649                                                 // Build the cache for the tbody cells
 650                                                 // to share between calculations for this sort action.
 651                                                 // Re-calculated each time a sort action is performed due to possiblity
 652                                                 // that sort values change. Shouldn't be too expensive, but if it becomes
 653                                                 // too slow an event based system should be implemented somehow where
 654                                                 // cells get event .change() and bubbles up to the <table> here
 655                                                 cache = buildCache( table );
 656
 657                                                 var totalRows = ( $table[0].tBodies[0] && $table[0].tBodies[0].rows.length ) || 0;
 658                                                 if ( !table.sortDisabled && totalRows > 0 ) {
 659                                                         // Get current column sort order
 660                                                         this.order = this.count % 2;
 661                                                         this.count++;
 662
 663                                                         var cell = this;
 664                                                         // Get current column index
 665                                                         var columns = headerToColumns[this.column];
 666                                                         var newSortList = $.map( columns, function (c) {
 667                                                                 // jQuery "helpfully" flattens the arrays...
 668                                                                 return [[c, cell.order]];
 669                                                         });
 670                                                         // Index of first column belonging to this header
 671                                                         var i = columns[0];
 672
 673                                                         if ( !e[config.sortMultiSortKey] ) {
 674                                                                 // User only wants to sort on one column set
 675                                                                 // Flush the sort list and add new columns
 676                                                                 config.sortList = newSortList;
 677                                                         } else {
 678                                                                 // Multi column sorting
 679                                                                 // It is not possible for one column to belong to multiple headers,
 680                                                                 // so this is okay - we don't need to check for every value in the columns array
 681                                                                 if ( isValueInArray( i, config.sortList ) ) {
 682                                                                         // The user has clicked on an already sorted column.
 683                                                                         // Reverse the sorting direction for all tables.
 684                                                                         for ( var j = 0; j < config.sortList.length; j++ ) {
 685                                                                                 var s = config.sortList[j],
 686                                                                                         o = config.headerList[s[0]];
 687                                                                                 if ( isValueInArray( s[0], newSortList ) ) {
 688                                                                                         o.count = s[1];
 689                                                                                         o.count++;
 690                                                                                         s[1] = o.count % 2;
 691                                                                                 }
 692                                                                         }
 693                                                                 } else {
 694                                                                         // Add columns to sort list array
 695                                                                         config.sortList = config.sortList.concat( newSortList );
 696                                                                 }
 697                                                         }
 698
 699                                                         // Set CSS for headers
 700                                                         setHeadersCss( $table[0], $headers, config.sortList, sortCSS, sortMsg, columnToHeader );
 701                                                         appendToTable(
 702                                                                 $table[0], multisort( $table[0], config.sortList, cache )
 703                                                         );
 704
 705                                                         // Stop normal event by returning false
 706                                                         return false;
 707                                                 }
 708
 709                                         // Cancel selection
 710                                         } ).mousedown( function () {
 711                                                 if ( config.cancelSelection ) {
 712                                                         this.onselectstart = function () {
 713                                                                 return false;
 714                                                         };
 715                                                         return false;
 716                                                 }
 717                                         } );
 718
 719                                         /**
 720                                          * Sorts the table. If no sorting is specified by passing a list of sort
 721                                          * objects, the table is sorted according to the initial sorting order.
 722                                          * Passing an empty array will reset sorting (basically just reset the headers
 723                                          * making the table appear unsorted).
 724                                          *
 725                                          * @param sortList {Array} (optional) List of sort objects.
 726                                          */
 727                                         $table.data( 'tablesorter' ).sort = function( sortList ) {
 728
 729                                                 if ( firstTime ) {
 730                                                         setupForFirstSort();
 731                                                 }
 732
 733                                                 if ( sortList === undefined ) {
 734                                                         sortList = config.sortList;
 735                                                 } else if ( sortList.length > 0 ) {
 736                                                         sortList = convertSortList( sortList );
 737                                                 }
 738
 739                                                 // re-build the cache for the tbody cells
 740                                                 cache = buildCache( table );
 741
 742                                                 // set css for headers
 743                                                 setHeadersCss( table, $headers, sortList, sortCSS, sortMsg, columnToHeader );
 744
 745                                                 // sort the table and append it to the dom
 746                                                 appendToTable( table, multisort( table, sortList, cache ) );
 747                                         };
 748
 749                                         // sort initially
 750                                         if ( config.sortList.length > 0 ) {
 751                                                 setupForFirstSort();
 752                                                 config.sortList = convertSortList( config.sortList );
 753                                                 $table.data( 'tablesorter' ).sort();
 754                                         }
 755
 756                                 } );
 757                         },
 758
 759                         addParser: function ( parser ) {
 760                                 var l = parsers.length,
 761                                         a = true;
 762                                 for ( var i = 0; i < l; i++ ) {
 763                                         if ( parsers[i].id.toLowerCase() === parser.id.toLowerCase() ) {
 764                                                 a = false;
 765                                         }
 766                                 }
 767                                 if ( a ) {
 768                                         parsers.push( parser );
 769                                 }
 770                         },
 771
 772                         formatDigit: function ( s ) {
 773                                 var out, c, p, i;
 774                                 if ( ts.transformTable !== false ) {
 775                                         out = '';
 776                                         for ( p = 0; p < s.length; p++ ) {
 777                                                 c = s.charAt(p);
 778                                                 if ( c in ts.transformTable ) {
 779                                                         out += ts.transformTable[c];
 780                                                 } else {
 781                                                         out += c;
 782                                                 }
 783                                         }
 784                                         s = out;
 785                                 }
 786                                 i = parseFloat( s.replace( /[, ]/g, '' ).replace( '\u2212', '-' ) );
 787                                 return isNaN( i ) ? 0 : i;
 788                         },
 789
 790                         formatFloat: function ( s ) {
 791                                 var i = parseFloat(s);
 792                                 return isNaN( i ) ? 0 : i;
 793                         },
 794
 795                         formatInt: function ( s ) {
 796                                 var i = parseInt( s, 10 );
 797                                 return isNaN( i ) ? 0 : i;
 798                         },
 799
 800                         clearTableBody: function ( table ) {
 801                                 $( table.tBodies[0] ).empty();
 802                         }
 803                 };
 804
 805         // Shortcut
 806         ts = $.tablesorter;
 807
 808         // Register as jQuery prototype method
 809         $.fn.tablesorter = function ( settings ) {
 810                 return ts.construct( this, settings );
 811         };
 812
 813         // Add default parsers
 814         ts.addParser( {
 815                 id: 'text',
 816                 is: function () {
 817                         return true;
 818                 },
 819                 format: function ( s ) {
 820                         s = $.trim( s.toLowerCase() );
 821                         if ( ts.collationRegex ) {
 822                                 var tsc = ts.collationTable;
 823                                 s = s.replace( ts.collationRegex, function ( match ) {
 824                                         var r = tsc[match] ? tsc[match] : tsc[match.toUpperCase()];
 825                                         return r.toLowerCase();
 826                                 } );
 827                         }
 828                         return s;
 829                 },
 830                 type: 'text'
 831         } );
 832
 833         ts.addParser( {
 834                 id: 'IPAddress',
 835                 is: function ( s ) {
 836                         return ts.rgx.IPAddress[0].test(s);
 837                 },
 838                 format: function ( s ) {
 839                         var a = s.split( '.' ),
 840                                 r = '',
 841                                 l = a.length;
 842                         for ( var i = 0; i < l; i++ ) {
 843                                 var item = a[i];
 844                                 if ( item.length === 1 ) {
 845                                         r += '00' + item;
 846                                 } else if ( item.length === 2 ) {
 847                                         r += '0' + item;
 848                                 } else {
 849                                         r += item;
 850                                 }
 851                         }
 852                         return $.tablesorter.formatFloat(r);
 853                 },
 854                 type: 'numeric'
 855         } );
 856
 857         ts.addParser( {
 858                 id: 'currency',
 859                 is: function ( s ) {
 860                         return ts.rgx.currency[0].test(s);
 861                 },
 862                 format: function ( s ) {
 863                         return $.tablesorter.formatDigit( s.replace( ts.rgx.currency[1], '' ) );
 864                 },
 865                 type: 'numeric'
 866         } );
 867
 868         ts.addParser( {
 869                 id: 'url',
 870                 is: function ( s ) {
 871                         return ts.rgx.url[0].test(s);
 872                 },
 873                 format: function ( s ) {
 874                         return $.trim( s.replace( ts.rgx.url[1], '' ) );
 875                 },
 876                 type: 'text'
 877         } );
 878
 879         ts.addParser( {
 880                 id: 'isoDate',
 881                 is: function ( s ) {
 882                         return ts.rgx.isoDate[0].test(s);
 883                 },
 884                 format: function ( s ) {
 885                         return $.tablesorter.formatFloat((s !== '') ? new Date(s.replace(
 886                         new RegExp( /-/g), '/')).getTime() : '0' );
 887                 },
 888                 type: 'numeric'
 889         } );
 890
 891         ts.addParser( {
 892                 id: 'usLongDate',
 893                 is: function ( s ) {
 894                         return ts.rgx.usLongDate[0].test(s);
 895                 },
 896                 format: function ( s ) {
 897                         return $.tablesorter.formatFloat( new Date(s).getTime() );
 898                 },
 899                 type: 'numeric'
 900         } );
 901
 902         ts.addParser( {
 903                 id: 'date',
 904                 is: function ( s ) {
 905                         return ( ts.dateRegex[0].test(s) || ts.dateRegex[1].test(s) || ts.dateRegex[2].test(s ));
 906                 },
 907                 format: function ( s ) {
 908                         var match;
 909                         s = $.trim( s.toLowerCase() );
 910
 911                         if ( ( match = s.match( ts.dateRegex[0] ) ) !== null ) {
 912                                 if ( mw.config.get( 'wgDefaultDateFormat' ) === 'mdy' || mw.config.get( 'wgContentLanguage' ) === 'en' ) {
 913                                         s = [ match[3], match[1], match[2] ];
 914                                 } else if ( mw.config.get( 'wgDefaultDateFormat' ) === 'dmy' ) {
 915                                         s = [ match[3], match[2], match[1] ];
 916                                 } else {
 917                                         // If we get here, we don't know which order the dd-dd-dddd
 918                                         // date is in. So return something not entirely invalid.
 919                                         return '99999999';
 920                                 }
 921                         } else if ( ( match = s.match( ts.dateRegex[1] ) ) !== null ) {
 922                                 s = [ match[3], '' + ts.monthNames[match[2]], match[1] ];
 923                         } else if ( ( match = s.match( ts.dateRegex[2] ) ) !== null ) {
 924                                 s = [ match[3], '' + ts.monthNames[match[1]], match[2] ];
 925                         } else {
 926                                 // Should never get here
 927                                 return '99999999';
 928                         }
 929
 930                         // Pad Month and Day
 931                         if ( s[1].length === 1 ) {
 932                                 s[1] = '0' + s[1];
 933                         }
 934                         if ( s[2].length === 1 ) {
 935                                 s[2] = '0' + s[2];
 936                         }
 937
 938                         var y;
 939                         if ( ( y = parseInt( s[0], 10) ) < 100 ) {
 940                                 // Guestimate years without centuries
 941                                 if ( y < 30 ) {
 942                                         s[0] = 2000 + y;
 943                                 } else {
 944                                         s[0] = 1900 + y;
 945                                 }
 946                         }
 947                         while ( s[0].length < 4 ) {
 948                                 s[0] = '0' + s[0];
 949                         }
 950                         return parseInt( s.join( '' ), 10 );
 951                 },
 952                 type: 'numeric'
 953         } );
 954
 955         ts.addParser( {
 956                 id: 'time',
 957                 is: function ( s ) {
 958                         return ts.rgx.time[0].test(s);
 959                 },
 960                 format: function ( s ) {
 961                         return $.tablesorter.formatFloat( new Date( '2000/01/01 ' + s ).getTime() );
 962                 },
 963                 type: 'numeric'
 964         } );
 965
 966         ts.addParser( {
 967                 id: 'number',
 968                 is: function ( s ) {
 969                         return $.tablesorter.numberRegex.test( $.trim( s ));
 970                 },
 971                 format: function ( s ) {
 972                         return $.tablesorter.formatDigit(s);
 973                 },
 974                 type: 'numeric'
 975         } );
 976
 977 }( jQuery, mediaWiki ) );