mambax7/alumni-26x

View on GitHub
media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js

Summary

Maintainability
F
1 mo
Test Coverage

Function tablesorterPager has 943 lines of code (exceeds 25 allowed). Consider refactoring.
Open

        tablesorterPager: new function() {

            this.defaults = {
                // target the pager markup
                container: null,

    File jquery.tablesorter.pager.js has 1014 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    /*!
    * tablesorter (FORK) pager plugin
    * updated 4/18/2017 (v2.28.8)
    */
    /*jshint browser:true, jquery:true, unused:false */

      Function init has 181 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

                  init = function(table, settings) {
                      var t, ctrls, fxn, size, $el,
                      c = table.config,
                      wo = c.widgetOptions,
                      p = c.pager = $.extend( true, {}, $.tablesorterPager.defaults, settings ),

        Function renderAjax has 103 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

                    renderAjax = function(data, table, p, xhr, settings, exception){
                        // process data
                        if ( typeof p.ajaxProcessing === 'function' ) {
        
                            // in case nothing is returned by ajax, empty out the table; see #1032

          Consider simplifying this complex logical expression.
          Open

                          if ( l.page === p.page && l.size === p.size && l.totalRows === p.totalRows &&
                          (l.currentFilters || []).join(',') === (p.currentFilters || []).join(',') &&
                          // check for ajax url changes see #730
                          (l.ajaxUrl || '') === (p.ajaxObject.url || '') &&
                          // & ajax url option changes (dynamically add/remove/rename sort & filter parameters)
          Severity: Critical
          Found in media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js - About 3 hrs to fix

            Function updatePageDisplay has 76 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                        updatePageDisplay = function(table, p, completed) {
                            if ( p.initializing ) { return; }
                            var s, t, $out, $el, indx, len, options, output,
                            c = table.config,
                            namespace = c.namespace + 'pager',

              Function moveToPage has 59 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                          moveToPage = function(table, p, pageMoved) {
                              if ( p.isDisabled ) { return; }
                              var tmp,
                              c = table.config,
                              $t = $(table),

                Function showError has 58 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    ts.showError = function( table, xhr, settings, exception ) {
                        var $row,
                            $table = $( table ),
                            c = $table[0].config,
                            wo = c && c.widgetOptions,

                  Function renderTable has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                              renderTable = function(table, rows, p) {
                                  var $tb, index, count, added,
                                  $t = $(table),
                                  c = table.config,
                                  f = c.$table.hasClass('hasFilters'),

                    Function buildPageSelect has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                                buildPageSelect = function( table, p ) {
                                    // Filter the options page number link array if it's larger than 'maxOptionSize'
                                    // as large page set links will slow the browser on large dom inserts
                                    var i, central_focus_size, focus_option_pages, insert_index, option_length, focus_length,
                                    pg = getTotalPages( table, p ) || 1,

                      Function getAjaxUrl has 37 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                                  getAjaxUrl = function(table, p) {
                                      var indx, len,
                                      c = table.config,
                                      url = (p.ajaxUrl) ? p.ajaxUrl
                                      // allow using "{page+1}" in the url string to switch to a non-zero based index

                        Function hideRows has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                                    hideRows = function(table, p){
                                        if (!p.ajaxUrl) {
                                            var i,
                                            lastIndex = 0,
                                            c = table.config,

                          Function enablePager has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                                      enablePager = function(table, p, triggered) {
                                          var info, size, $el,
                                          c = table.config;
                                          p.$container.find(p.cssGoto + ',' + p.cssPageSize + ',.ts-startRow, .ts-page')
                                          .removeClass(p.cssDisabled)

                            Consider simplifying this complex logical expression.
                            Open

                                                if (typeof p.output === 'function') {
                                                    s = p.output(table, p);
                                                } else {
                                                    output = $out
                                                        // get output template from data-pager-output or data-pager-output-filtered
                            Severity: Critical
                            Found in media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js - About 1 hr to fix

                              Function getAjax has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                          getAjax = function(table, p) {
                                              var url = getAjaxUrl(table, p),
                                              $doc = $(document),
                                              counter,
                                              c = table.config,

                                Function showAllRows has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                            showAllRows = function(table, p) {
                                                var index, $controls, len;
                                                if ( p.ajax ) {
                                                    pagerArrows( table, p, true );
                                                } else {

                                  Avoid deeply nested control flow statements.
                                  Open

                                                              if (p.processAjaxOnInit) {
                                                                  c.$tbodies.eq(0).html( tds );
                                                              }
                                  Severity: Major
                                  Found in media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js - About 45 mins to fix

                                    Function renderAjax has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                    Open

                                                renderAjax = function(data, table, p, xhr, settings, exception){
                                    Severity: Minor
                                    Found in media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js - About 45 mins to fix

                                      Avoid deeply nested control flow statements.
                                      Open

                                                                      if ( j === e && rows[i].style.display !== 'none' && rows[i].className.match(ts.css.cssHasChild) ) {
                                                                          lastIndex = i;
                                                                      }
                                      Severity: Major
                                      Found in media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js - About 45 mins to fix

                                        Avoid deeply nested control flow statements.
                                        Open

                                                                        if ( $h.find('.' + ts.css.icon).length ) {
                                                                            icon = $h.find('.' + ts.css.icon).clone(true);
                                                                            $h.find('.' + ts.css.headerIn).html( th[j] ).append(icon);
                                                                            if ( hsh && $sh.length ) {
                                                                                icon = $sh.eq(j).find('.' + ts.css.icon).clone(true);
                                        Severity: Major
                                        Found in media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js - About 45 mins to fix

                                          Avoid deeply nested control flow statements.
                                          Open

                                                                      for ( i = 0; i < l; i++ ) {
                                                                          tds += '<tr>';
                                                                          for ( j = 0; j < d[i].length; j++ ) {
                                                                              // build tbody cells; watch for data containing HTML markup - see #434
                                                                              tds += /^\s*<td/.test(d[i][j]) ? $.trim(d[i][j]) : '<td>' + d[i][j] + '</td>';
                                          Severity: Major
                                          Found in media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js - About 45 mins to fix

                                            Avoid deeply nested control flow statements.
                                            Open

                                                                            if (last !== j && j >= s && j < e) {
                                                                                p.cacheIndex[ p.cacheIndex.length ] = i;
                                                                                last = j;
                                                                            }
                                            Severity: Major
                                            Found in media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js - About 45 mins to fix

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                  ts.showError = function( table, xhr, settings, exception ) {
                                                      var $row,
                                                          $table = $( table ),
                                                          c = $table[0].config,
                                                          wo = c && c.widgetOptions,
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1298..1369

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 642.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                  if (typeof p.output === 'function') {
                                                                      s = p.output(table, p);
                                                                  } else {
                                                                      output = $out
                                                                          // get output template from data-pager-output or data-pager-output-filtered
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 477..508

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 470.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              if (large_collection) {
                                                                  focus_option_pages = [];
                                                                  // don't allow central focus size to be > 5 on either side of current page
                                                                  central_focus_size = Math.max( Math.floor( p.maxOptionSize / skip_set_size ) - 1, 5 );
                                              
                                              
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 571..600

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 332.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                  for ( i = 0; i < l; i++ ){
                                                                      if ( !p.regexFiltered.test(rows[i].className) ) {
                                                                          if (j === s && rows[i].className.match(c.cssChildRow)) {
                                                                              // hide child rows @ start of pager (if already visible)
                                                                              rows[i].style.display = 'none';
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 674..694

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 320.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                      if (!$.isArray(result)) {
                                                                          p.ajaxData = result;
                                                                          c.totalRows = p.totalRows = result.total;
                                                                          c.filteredRows = p.filteredRows = typeof result.filteredRows !== 'undefined' ? result.filteredRows : result.total;
                                                                          th = result.headers;
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 752..771

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 301.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              if (p.fixedHeight && !p.isDisabled) {
                                                                  h = $.data(table, 'pagerSavedHeight');
                                                                  if (h) {
                                                                      bs = 0;
                                                                      if ($(table).css('border-spacing').split(' ').length > 1) {
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 620..636

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 273.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              if (hasFilters && !p.ajax) {
                                                                  if (ts.isEmptyObject(c.cache)) {
                                                                      // delayInit: true so nothing is in the cache
                                                                      p.filteredRows = p.totalRows = c.$tbodies.eq(0).children('tr').not( p.countChildRows ? '' : '.' + c.cssChildRow ).length;
                                                                  } else {
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 429..446

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 251.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                      if (d instanceof jQuery) {
                                                                          if (p.processAjaxOnInit) {
                                                                              // append jQuery object
                                                                              c.$tbodies.eq(0).empty();
                                                                              c.$tbodies.eq(0).append(d);
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 773..793

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 244.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              if ( !p.removeRows ) {
                                                                  hideRows(table, p);
                                                              } else {
                                                                  ts.clearTableBody(table);
                                                                  $tb = ts.processTbody(table, c.$tbodies.eq(0), true);
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 972..994

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 230.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                              if ( $h.find('.' + ts.css.icon).length ) {
                                                                                  icon = $h.find('.' + ts.css.icon).clone(true);
                                                                                  $h.find('.' + ts.css.headerIn).html( th[j] ).append(icon);
                                                                                  if ( hsh && $sh.length ) {
                                                                                      icon = $sh.eq(j).find('.' + ts.css.icon).clone(true);
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 808..822

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 191.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              if ( l.page === p.page && l.size === p.size && l.totalRows === p.totalRows &&
                                                              (l.currentFilters || []).join(',') === (p.currentFilters || []).join(',') &&
                                                              // check for ajax url changes see #730
                                                              (l.ajaxUrl || '') === (p.ajaxObject.url || '') &&
                                                              // & ajax url option changes (dynamically add/remove/rename sort & filter parameters)
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1090..1098

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 181.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                  if ($out.length) {
                                                                      $out[ ($out[0].nodeName === 'INPUT') ? 'val' : 'html' ](s);
                                                                      // rebind startRow/page inputs
                                                                      $out.find('.ts-startRow, .ts-page').unbind('change' + namespace).bind('change' + namespace, function(){
                                                                          var v = $(this).val(),
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 519..530

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 164.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              if (filterCol) {
                                                                  filterCol = filterCol[1];
                                                                  len = filterList.length;
                                                                  for (indx = 0; indx < len; indx++) {
                                                                      if (filterList[indx]) {
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 923..934

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 149.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              if (sortCol) {
                                                                  sortCol = sortCol[1];
                                                                  len = sortList.length;
                                                                  for (indx = 0; indx < len; indx++) {
                                                                      arry[ arry.length ] = sortCol + '[' + sortList[indx][0] + ']=' + sortList[indx][1];
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 913..922

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 143.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              if (p.initialized && completed !== false) {
                                                                  if (c.debug) {
                                                                      console.log('Pager: Triggering pagerComplete');
                                                                  }
                                                                  c.$table.triggerHandler('pagerComplete', p);
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 534..546

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 126.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                  if ( lastIndex > 0 && rows[lastIndex].className.match(ts.css.cssHasChild) ) {
                                                                      while ( ++lastIndex < l && rows[lastIndex].className.match(c.cssChildRow) ) {
                                                                          rows[lastIndex].style.display = '';
                                                                      }
                                                                  }
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 696..700

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 97.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                  if (ts.filter.equalFilters) {
                                                                      filtersEqual = ts.filter.equalFilters(c, c.lastSearch, p.currentFilters);
                                                                  } else {
                                                                      // will miss filter changes of the same value in a different column, see #1363
                                                                      filtersEqual = (c.lastSearch || []).join('') !== (p.currentFilters || []).join('');
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 256..261

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 97.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                  if ( exception ) {
                                                                      if (c.debug) {
                                                                          console.error('Pager: >> Ajax Error', xhr, settings, exception);
                                                                      }
                                                                      ts.showError( table, xhr, settings, exception );
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 743..829

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 84.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              url = (p.ajaxUrl) ? p.ajaxUrl
                                                              // allow using "{page+1}" in the url string to switch to a non-zero based index
                                                              .replace(/\{page([\-+]\d+)?\}/, function(s, n){ return p.page + (n ? parseInt(n, 10) : 0); })
                                                              // this will pass "all" to server when size is set to "all"
                                                              .replace(/\{size\}/g, p.size) : '',
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 903..907

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 78.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              p.regexRows = new RegExp('(' + (wo.filter_filteredRow || 'filtered') + '|' + c.selectorRemove.slice(1) + '|' + c.cssChildRow + ')');
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 187..188

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 65.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                  p.size = t.size === 'all' ? t.size : ( isNaN( t.size ) ? p.size : t.size ) || p.setSize || 10;
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 182..182

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 63.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              option_pages = $.grep(option_pages, function(value, indx) {
                                                                  return $.inArray(value, option_pages) === indx;
                                                              })
                                                              .sort(function(a, b) { return a - b; });
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 603..608

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 63.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                  if (e.type === 'pagerUpdate') {
                                                                      num = typeof num === 'undefined' ? p.page + 1 : num;
                                                                      p.last.page = true;
                                                                  }
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 326..329

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 59.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                  for (i = 0; i < p.totalRows; i++) {
                                                                      rows[ rows.length ] = n[i][c.columns].$row;
                                                                  }
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1058..1060

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 56.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                  p.startRow = (t) ? sz * p.page + 1 : (p.filteredRows === 0 ? 0 : sz * p.page + 1);
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 472..472

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 55.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                      for (indx = 0; indx < len; indx++) {
                                                                          t += '<option value="' + options[indx] + '">' + options[indx] + '</option>';
                                                                      }
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 513..515

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 54.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 4 locations. Consider refactoring.
                                              Open

                                                                      p.filteredRows = typeof tmp.filtered !== 'undefined' ? tmp.filtered :
                                                                      ( c.debug ? console.error('Pager: no initial filtered page set!') || 0 : 0 );
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 778..779
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1116..1117
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1118..1119

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 53.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 4 locations. Consider refactoring.
                                              Open

                                                                      p.totalRows = typeof tmp.total !== 'undefined' ? tmp.total :
                                                                      ( c.debug ? console.error('Pager: no initial total page set!') || 0 : 0 );
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 780..781
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1116..1117
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1118..1119

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 53.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              if (!$b.children('tr:visible').length) {
                                                                  $b.append('<tr class="pagerSavedHeightSpacer ' + c.selectorRemove.slice(1) + '"><td>&nbsp</td></tr>');
                                                              }
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 646..648

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 52.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                  if (e.type === 'filterStart' && p.pageReset !== false && !filtersEqual) {
                                                                      p.page = p.pageReset; // fixes #456 & #565
                                                                  }
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 263..265

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 52.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                  p.totalRows = $rows.length - ( p.countChildRows ? 0 : $rows.filter('.' + c.cssChildRow).length );
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 298..299

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 49.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              for ( i = option_pages_start_page; i <= pg; ) {
                                                                  option_pages[ option_pages.length ] = i;
                                                                  i = i + ( large_collection ? skip_set_size : 1 );
                                                              }
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 565..568

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 49.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                  p.totalRows = p.countChildRows ? c.$tbodies.eq(0).children('tr').length : rows.length;
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1284..1284

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 49.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              if (table.isUpdating) {
                                                                  if (c.debug) {
                                                                      console.log('Pager: Triggering updateComplete');
                                                                  }
                                                                  $t.triggerHandler('updateComplete', [ table, true ]);
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 796..801

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 48.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                                  if (table.isUpdating) {
                                                                      if (c.debug) {
                                                                          console.log('Pager: Triggering updateComplete');
                                                                      }
                                                                      $t.triggerHandler('updateComplete', [ table, true ]);
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 680..685

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 48.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              l.currentFilters = (l.currentFilters || []).join('') === '' ? [] : l.currentFilters;
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1087..1087

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 46.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 8 locations. Consider refactoring.
                                              Open

                                                                  p.totalPages = p.size === 'all' ? 1 : Math.ceil( p.totalRows / p.size );
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 837..837
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 838..838
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 1029..1029
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 300..300
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1181..1181
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1182..1182
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1286..1286

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 45.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 8 locations. Consider refactoring.
                                              Open

                                                                  p.totalPages = p.size === 'all' ? 1 : Math.ceil( p.totalRows / p.size );
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 837..837
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 838..838
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 1170..1170
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 300..300
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1181..1181
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1182..1182
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1286..1286

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 45.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 8 locations. Consider refactoring.
                                              Open

                                                              p.totalPages = p.size === 'all' ? 1 : Math.ceil( p.totalRows / p.size );
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 838..838
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 1029..1029
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 1170..1170
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 300..300
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1181..1181
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1182..1182
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1286..1286

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 45.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 8 locations. Consider refactoring.
                                              Open

                                                              p.filteredPages = p.size === 'all' ? 1 : Math.ceil( p.filteredRows / p.size );
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 837..837
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 1029..1029
                                              media/jquery/tablesorter-master/addons/pager/jquery.tablesorter.pager.js on lines 1170..1170
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 300..300
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1181..1181
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1182..1182
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1286..1286

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 45.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                              Open

                                                              p.currentFilters = (p.currentFilters || []).join('') === '' ? [] : p.currentFilters;
                                              media/jquery/tablesorter-master/js/widgets/widget-pager.js on lines 1088..1088

                                              Duplicated Code

                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                              Tuning

                                              This issue has a mass of 45.

                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                              Refactorings

                                              Further Reading

                                              There are no issues that match your filters.

                                              Category
                                              Status