bronycub/sugarcub

View on GitHub
core/static/vendor/jquery-expander/test/qunit/qunit.js

Summary

Maintainability
F
2 wks
Test Coverage

File qunit.js has 964 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*
 * QUnit - A JavaScript Unit Testing Framework
 * 
 * http://docs.jquery.com/QUnit
 *
Severity: Major
Found in core/static/vendor/jquery-expander/test/qunit/qunit.js - About 2 days to fix

    Function jsDump has 148 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    QUnit.jsDump = (function() {
        function quote( str ) {
            return '"' + str.toString().replace(/"/g, '\\"') + '"';
        };
        function literal( o ) {
    Severity: Major
    Found in core/static/vendor/jquery-expander/test/qunit/qunit.js - About 5 hrs to fix

      Function test has 144 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          test: function(testName, expected, callback, async) {
              var name = '<span class="test-name">' + testName + '</span>', testEnvironment, testEnvironmentArg;
      
              if ( arguments.length === 2 ) {
                  callback = expected;
      Severity: Major
      Found in core/static/vendor/jquery-expander/test/qunit/qunit.js - About 5 hrs to fix

        Function equiv has 117 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        QUnit.equiv = function () {
        
            var innerEquiv; // the real equiv function
            var callers = []; // stack to decide between skip/abort functions
            var parents = []; // stack to avoiding loops from circular referencing
        Severity: Major
        Found in core/static/vendor/jquery-expander/test/qunit/qunit.js - About 4 hrs to fix

          Function diff has 107 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          QUnit.diff = (function() {
              function diff(o, n){
                  var ns = new Object();
                  var os = new Object();
                  
          Severity: Major
          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js - About 4 hrs to fix

            Function callbacks has 86 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                var callbacks = function () {
            
                    // for string, boolean, number and null
                    function useStrictEquality(b, a) {
                        if (b instanceof a.constructor || a instanceof b.constructor) {
            Severity: Major
            Found in core/static/vendor/jquery-expander/test/qunit/qunit.js - About 3 hrs to fix

              Function diff has 60 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  function diff(o, n){
                      var ns = new Object();
                      var os = new Object();
                      
                      for (var i = 0; i < n.length; i++) {
              Severity: Major
              Found in core/static/vendor/jquery-expander/test/qunit/qunit.js - About 2 hrs to fix

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

                function done() {
                    if ( config.doneTimer && window.clearTimeout ) {
                        window.clearTimeout( config.doneTimer );
                        config.doneTimer = null;
                    }
                Severity: Minor
                Found in core/static/vendor/jquery-expander/test/qunit/qunit.js - About 1 hr to fix

                  Function objectType has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      objectType: function( obj ) {
                          if (typeof obj === "undefined") {
                                  return "undefined";
                  
                          // consider: typeof null === object
                  Severity: Minor
                  Found in core/static/vendor/jquery-expander/test/qunit/qunit.js - About 1 hr to fix

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

                                "object": function (b, a) {
                                    var i, j, loop;
                                    var eq = true; // unless we can proove it
                                    var aProperties = [], bProperties = []; // collection of strings
                    
                    
                    Severity: Minor
                    Found in core/static/vendor/jquery-expander/test/qunit/qunit.js - About 1 hr to fix

                      Avoid too many return statements within this function.
                      Open

                                      return "object";
                      Severity: Major
                      Found in core/static/vendor/jquery-expander/test/qunit/qunit.js - About 30 mins to fix

                        Avoid too many return statements within this function.
                        Open

                                return undefined;
                        Severity: Major
                        Found in core/static/vendor/jquery-expander/test/qunit/qunit.js - About 30 mins to fix

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

                                  for (var i = 0; i < n.length - 1; i++) {
                                      if (n[i].text != null && n[i + 1].text == null && n[i].row + 1 < o.length && o[n[i].row + 1].text == null &&
                                      n[i + 1] == o[n[i].row + 1]) {
                                          n[i + 1] = {
                                              text: n[i + 1],
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 1 day to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1575..1587

                          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 227.

                          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 (var i = n.length - 1; i > 0; i--) {
                                      if (n[i].text != null && n[i - 1].text == null && n[i].row > 0 && o[n[i].row - 1].text == null &&
                                      n[i - 1] == o[n[i].row - 1]) {
                                          n[i - 1] = {
                                              text: n[i - 1],
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 1 day to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1589..1601

                          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 219.

                          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

                              innerEquiv = function () { // can take multiple arguments
                                  var args = Array.prototype.slice.apply(arguments);
                                  if (args.length < 2) {
                                      return true; // end transition
                                  }
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 1 day to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1252..1271

                          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 217.

                          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 (var i = 0; i < out.n.length; i++) {
                                          if (out.n[i].text == null) {
                                              str += '<ins>' + out.n[i] + nSpace[i] + "</ins>";
                                          }
                                          else {
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 1 day to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1644..1656

                          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 200.

                          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 (ns[i].rows.length == 1 && typeof(os[i]) != "undefined" && os[i].rows.length == 1) {
                                          n[ns[i].rows[0]] = {
                                              text: n[ns[i].rows[0]],
                                              row: os[i].rows[0]
                                          };
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 7 hrs to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1563..1572

                          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

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

                          function getText( elems ) {
                              var ret = "", elem;
                          
                              for ( var i = 0; elems[i]; i++ ) {
                                  elem = elems[i];
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 4 hrs to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1485..1502

                          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

                                          for (i = 0; i < len; i++) {
                                              loop = false;
                                              for(j=0;j<parents.length;j++){
                                                  if(parents[j] === a[i]){
                                                      loop = true;//dont rewalk array
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 4 hrs to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1183..1194

                          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 122.

                          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

                          function diff( a, b ) {
                              var result = a.slice();
                              for ( var i = 0; i < result.length; i++ ) {
                                  for ( var j = 0; j < b.length; j++ ) {
                                      if ( result[i] === b[j] ) {
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 4 hrs to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1031..1043

                          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 120.

                          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

                              triggerEvent: function( elem, type, event ) {
                                  if ( document.createEvent ) {
                                      event = document.createEvent("MouseEvents");
                                      event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView,
                                          0, 0, 0, 0, 0, false, false, false, false, 0, null);
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 3 hrs to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 598..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 107.

                          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 (out.n[0].text == null) {
                                          for (n = 0; n < out.o.length && out.o[n].text == null; n++) {
                                              str += '<del>' + out.o[n] + oSpace[n] + "</del>";
                                          }
                                      }
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 3 hrs to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1638..1642

                          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 103.

                          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 (var i = 0; i < o.length; i++) {
                                      if (os[o[i]] == null) 
                                          os[o[i]] = {
                                              rows: new Array(),
                                              n: null
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 3 hrs to fix
                          core/static/vendor/jquery-expander/test/qunit/qunit.js on lines 1143..1150

                          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 95.

                          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 (var i = 0; i < n.length; i++) {
                                      if (ns[n[i]] == null) 
                                          ns[n[i]] = {
                                              rows: new Array(),
                                              o: null
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 3 hrs to fix
                          core/static/vendor/jquery-expander/test/qunit/qunit.js on lines 1152..1159

                          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 95.

                          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

                              function bindCallbacks(o, callbacks, args) {
                                  var prop = QUnit.objectType(o);
                                  if (prop) {
                                      if (QUnit.objectType(callbacks[prop]) === "function") {
                                          return callbacks[prop].apply(callbacks, args);
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 2 hrs to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1103..1112

                          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 88.

                          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

                          function addEvent(elem, type, fn) {
                              if ( elem.addEventListener ) {
                                  elem.addEventListener( type, fn, false );
                              } else if ( elem.attachEvent ) {
                                  elem.attachEvent( "on" + type, fn );
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 1 hr to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1059..1067

                          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 73.

                          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 ( target.nodeName.toLowerCase() == "span" || target.nodeName.toLowerCase() == "b" ) {
                                                  target = target.parentNode;
                                              }
                          Severity: Minor
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 50 mins to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 208..210

                          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

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

                                              if ( assertion.result ) {
                                                  good++;
                                              } else {
                                                  bad++;
                                                  config.stats.bad++;
                          Severity: Minor
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 50 mins to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 171..177

                          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 51.

                          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 3 locations. Consider refactoring.
                          Open

                                      "function": function () {
                                          var caller = callers[callers.length - 1];
                                          return caller !== Object &&
                                                  typeof caller !== "undefined";
                                      },
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 2 other locations - About 45 mins to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1162..1165
                          core/static/vendor/jquery-expander/test/qunit/qunit.1.19.0.js on lines 1519..1522

                          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 50.

                          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

                                  var out = diff(o == "" ? [] : o.split(/\s+/), n == "" ? [] : n.split(/\s+/));
                          Severity: Minor
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 45 mins to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1612..1612

                          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 50.

                          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 3 locations. Consider refactoring.
                          Open

                                      "date": function (b, a) {
                                          return QUnit.objectType(b) === "date" && a.valueOf() === b.valueOf();
                                      },
                          Severity: Major
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 2 other locations - About 40 mins to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1144..1146
                          core/static/vendor/jquery-expander/test/qunit/qunit.1.19.0.js on lines 1497..1499

                          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

                                          var ret = 'function',
                                              name = 'name' in fn ? fn.name : (reName.exec(fn)||[])[1];//functions never have name in IE
                          Severity: Minor
                          Found in core/static/vendor/jquery-expander/test/qunit/qunit.js and 1 other location - About 30 mins to fix
                          core/static/vendor/bootstrap-datepicker/tests/assets/qunit.js on lines 1404..1405

                          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