jquery.tablesorter: Reset unaffected columns' sort counts when sorting

The column sort count (which is used to determine the sort order when
clicking a table header cell) was not reset on table columns unaffected
by the sorting. Sorting a column in ascending order, then sorting another
column and finally sorting the first column again would cause that column
to be sorted in descending order although it should be ordered in the
default (ascending) order again (see test added).

Change-Id: I3dd49bab07f9a02d9e1d531f1397396025fe77e0

diff --git a/resources/jquery/jquery.tablesorter.js b/resources/jquery/jquery.tablesorter.js
index e08c9aa..b28dab2 100644 (file)
--- a/resources/jquery/jquery.tablesorter.js
+++ b/resources/jquery/jquery.tablesorter.js
@@ -325,6 +325,40 @@
 
        }
 
+       /**
+        * Sets the sort count of the columns that are not affected by the sorting to have them sorted
+        * in default (ascending) order when their header cell is clicked the next time.
+        *
+        * @param {jQuery} $headers
+        * @param {Number[][]} sortList
+        * @param {Number[][]} headerToColumns
+        */
+       function setHeadersOrder( $headers, sortList, headerToColumns ) {
+               // Loop through all headers to retrieve the indices of the columns the header spans across:
+               $.each( headerToColumns, function( headerIndex, columns ) {
+
+                       $.each( columns, function( i, columnIndex ) {
+                               var header = $headers[headerIndex];
+
+                               if ( !isValueInArray( columnIndex, sortList ) ) {
+                                       // Column shall not be sorted: Reset header count and order.
+                                       header.order = 0;
+                                       header.count = 0;
+                               } else {
+                                       // Column shall be sorted: Apply designated count and order.
+                                       $.each( sortList, function( j, sortColumn ) {
+                                               if ( sortColumn[0] === i ) {
+                                                       header.order = sortColumn[1];
+                                                       header.count = sortColumn[1] + 1;
+                                                       return false;
+                                               }
+                                       } );
+                               }
+                       } );
+
+               } );
+       }
+
        function isValueInArray( v, a ) {
                var l = a.length;
                for ( var i = 0; i < l; i++ ) {
@@ -572,7 +606,7 @@
                $.each( sortObjects, function( i, sortObject ) {
                        $.each ( sortObject, function( columnIndex, order ) {
                                var orderIndex = ( order === 'desc' ) ? 1 : 0;
-                               sortList.push( [columnIndex, orderIndex] );
+                               sortList.push( [parseInt( columnIndex, 10 ), orderIndex] );
                        } );
                } );
                return sortList;
@@ -758,6 +792,9 @@
                                                                }
                                                        }
 
+                                                       // Reset order/counts of cells not affected by sorting
+                                                       setHeadersOrder( $headers, config.sortList, headerToColumns );
+
                                                        // Set CSS for headers
                                                        setHeadersCss( $table[0], $headers, config.sortList, sortCSS, sortMsg, columnToHeader );
                                                        appendToTable(
@@ -798,6 +835,10 @@
                                                        sortList = convertSortList( sortList );
                                                }
 
+                                               // Set each column's sort count to be able to determine the correct sort
+                                               // order when clicking on a header cell the next time
+                                               setHeadersOrder( $headers, sortList, headerToColumns );
+
                                                // re-build the cache for the tbody cells
                                                cache = buildCache( table );
 

diff --git a/tests/qunit/suites/resources/jquery/jquery.tablesorter.test.js b/tests/qunit/suites/resources/jquery/jquery.tablesorter.test.js
index 307b044..4b99c49 100644 (file)
--- a/tests/qunit/suites/resources/jquery/jquery.tablesorter.test.js
+++ b/tests/qunit/suites/resources/jquery/jquery.tablesorter.test.js
@@ -179,6 +179,18 @@
                        $table.find( '.headerSort:eq(0)' ).click();
                }
        );
+       tableTest(
+               'Basic planet table: ascending by name (multiple clicks)',
+               header,
+               planets,
+               ascendingName,
+               function ( $table ) {
+                       $table.tablesorter();
+                       $table.find( '.headerSort:eq(0)' ).click();
+                       $table.find( '.headerSort:eq(1)' ).click();
+                       $table.find( '.headerSort:eq(0)' ).click();
+               }
+       );
        tableTest(
                'Basic planet table: descending by name',
                header,
@@ -273,6 +285,35 @@
                        $table.data( 'tablesorter' ).sort();
                }
        );
+       tableTest(
+               'Sort via click event after having initialized the tablesorter with initial sorting',
+               header,
+               initial,
+               descasc,
+               function ( $table ) {
+                       $table.tablesorter(
+                               { sortList: [ { 0: 'asc' }, { 1: 'asc' } ] }
+                       );
+                       $table.find( '.headerSort:eq(0)' ).click();
+               }
+       );
+       tableTest(
+               'Multi-sort via click event after having initialized the tablesorter with initial sorting',
+               header,
+               initial,
+               asc,
+               function ( $table ) {
+                       $table.tablesorter(
+                               { sortList: [ { 0: 'desc' }, { 1: 'desc' } ] }
+                       );
+                       $table.find( '.headerSort:eq(0)' ).click();
+
+                       // Pretend to click while pressing the multi-sort key
+                       var event = $.Event( 'click' );
+                       event[$table.data( 'tablesorter' ).config.sortMultiSortKey] = true;
+                       $table.find( '.headerSort:eq(1)' ).trigger( event );
+               }
+       );
        QUnit.test( 'Reset sorting making table appear unsorted', 3, function ( assert ) {
                var $table = tableCreate( header, initial );
                $table.tablesorter(
@@ -325,6 +366,20 @@
                        $table.find( '.headerSort:eq(0)' ).click();
                }
        );
+       tableTest( 'Sorting with colspanned headers: sort spanned column twice',
+               header,
+               initial,
+               [ caa4, bbc2, abc3, aab5, aaa1 ],
+               function ( $table ) {
+                       // Make colspanned header for test
+                       $table.find( 'tr:eq(0) th:eq(1), tr:eq(0) th:eq(2)' ).remove();
+                       $table.find( 'tr:eq(0) th:eq(0)' ).prop( 'colspan', '3' );
+
+                       $table.tablesorter();
+                       $table.find( '.headerSort:eq(0)' ).click();
+                       $table.find( '.headerSort:eq(0)' ).click();
+               }
+       );
        tableTest( 'Sorting with colspanned headers: subsequent column',
                header,
                initial,
@@ -338,6 +393,21 @@
                        $table.find( '.headerSort:eq(1)' ).click();
                }
        );
+       tableTest( 'Sorting with colspanned headers: sort subsequent column twice',
+               header,
+               initial,
+               [ aab5, caa4, abc3, bbc2, aaa1 ],
+               function ( $table ) {
+                       // Make colspanned header for test
+                       $table.find( 'tr:eq(0) th:eq(1), tr:eq(0) th:eq(2)' ).remove();
+                       $table.find( 'tr:eq(0) th:eq(0)' ).prop( 'colspan', '3' );
+
+                       $table.tablesorter();
+                       $table.find( '.headerSort:eq(1)' ).click();
+                       $table.find( '.headerSort:eq(1)' ).click();
+               }
+       );
+
 
        // Regression tests!
        tableTest(