adobe/brackets

View on GitHub
src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js

Summary

Maintainability
F
3 mos
Test Coverage

Function JSHINT has a Cognitive Complexity of 1892 (exceeds 5 allowed). Consider refactoring.
Open

var JSHINT = (function () {
    "use strict";

    var anonname,       // The guessed name for anonymous functions.

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Function JSHINT has 3618 lines of code (exceeds 25 allowed). Consider refactoring.
Open

var JSHINT = (function () {
    "use strict";

    var anonname,       // The guessed name for anonymous functions.

    File jshint.js has 3623 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    /*!
     * JSHint, by JSHint Community.
     *
     * Licensed under the same slightly modified MIT license that JSLint is.
     * It stops evil-doers everywhere.

      Function lex has 607 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          var lex = (function lex() {
              var character, from, line, s;
      
      // Private lex methods
      
      

        Function token has 491 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

                    token: function () {
                        var b, c, captures, d, depth, high, i, l, low, q, t, isLiteral, isInRange;
        
                        function match(x) {
                            var r = x.exec(s), r1;

          Function itself has 118 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              var itself = function (s, o, g) {
                  var a, i, k;
                  JSHINT.errors = [];
                  JSHINT.undefs = [];
                  predefined = Object.create(standard);

            Function nud has 114 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                    x.nud = function () {
                        var b, f, i, j, p, t;
                        var props = {}; // All properties, including accessors
            
                        function saveProperty(name, token) {

              Function report has 110 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  itself.report = function (option) {
                      var data = itself.data();
              
                      var a = [], c, e, err, f, i, k, l, m = '', n, o = [], s;
              
              

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

                                function string(x) {
                                    var c, j, r = '', allowNewLine = false;
                
                                    if (jsonmode && x !== '"') {
                                        warningAt("Strings must use doublequote.",

                  Function labelled has 101 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      blockstmt('switch', function () {
                          var t = nexttoken,
                              g = false;
                          funct['(breakage)'] += 1;
                          advance('(');

                    Function doOption has 96 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                        function doOption() {
                            var b, obj, filter, o = nexttoken.value, t, v;
                            switch (o) {
                            case '*/':
                                error("Unbegun comment.");

                      Function nud has 90 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                              nud: function () {
                                  var v = this.value,
                                      s = scope[v],
                                      f;
                      
                      

                        Function jsonValue has 87 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                            function jsonValue() {
                        
                                function jsonObject() {
                                    var o = {}, t = nexttoken;
                                    advance('{');

                          Function labelled has 83 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                              blockstmt('for', function () {
                                  var s, t = nexttoken;
                                  funct['(breakage)'] += 1;
                                  funct['(loopage)'] += 1;
                                  advance('(');

                            Function data has 72 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                itself.data = function () {
                            
                                    var data = { functions: [], options: option }, fu, globals, implieds = [], f, i, j,
                                        members = [], n, unused = [], v;
                                    if (itself.errors.length) {

                              Function block has 67 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                  function block(ordinary, stmt, isfunc) {
                                      var a,
                                          b = inblock,
                                          old_indent = indent,
                                          m,

                                Function exps has 62 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                    infix('(', function (left, that) {
                                        if (prevtoken.id !== '}' && prevtoken.id !== ')') {
                                            nobreak(prevtoken, token);
                                        }
                                        nospace();

                                  Function advance has 49 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                      function advance(id, t) {
                                          switch (token.id) {
                                          case '(number)':
                                              if (nexttoken.id === '.') {
                                                  warning("A dot following a number can be confused with a decimal point.", token);

                                    Function statement has 48 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                        function statement(noindent) {
                                            var i = indent, r, s = scope, t = nexttoken;
                                    
                                            if (t.id === ";") {
                                                advance(";");

                                      Function it has 43 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                              function it(type, value) {
                                                  var i, t;
                                                  if (type === '(color)' || type === '(range)') {
                                                      t = {type: type};
                                                  } else if (type === '(punctuator)' ||

                                        Function directives has 42 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                            function directives() {
                                                var i, p, pn;
                                        
                                                for (;;) {
                                                    if (nexttoken.id === "(string)") {

                                          Function conststatement has 42 lines of code (exceeds 25 allowed). Consider refactoring.
                                          Open

                                                  var conststatement = stmt('const', function (prefix) {
                                                      var id, name, value;
                                          
                                                      this.first = [];
                                                      for (;;) {

                                            Function varstatement has 42 lines of code (exceeds 25 allowed). Consider refactoring.
                                            Open

                                                var varstatement = stmt('var', function (prefix) {
                                                    // JavaScript does not have block scope. It only has function scope. So,
                                                    // declaring a variable in a block can have unexpected consequences.
                                                    var id, name, value;
                                            
                                            

                                              Function assume has 39 lines of code (exceeds 25 allowed). Consider refactoring.
                                              Open

                                                  function assume() {
                                                      if (option.couch) {
                                                          combine(predefined, couch);
                                                      }
                                              
                                              

                                                Function expression has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                                                Open

                                                    function expression(rbp, initial) {
                                                        var left, isArray = false;
                                                
                                                        if (nexttoken.id === '(end)')
                                                            error("Unexpected early end of program.", token);

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

                                                          function jsonObject() {
                                                              var o = {}, t = nexttoken;
                                                              advance('{');
                                                              if (nexttoken.id !== '}') {
                                                                  for (;;) {

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

                                                        function assignop(s, f) {
                                                            symbol(s, 20).exps = true;
                                                            return infix(s, function (left, that) {
                                                                var l;
                                                                that.left = left;

                                                      Function warning has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                      Open

                                                          function warning(m, t, a, b, c, d) {
                                                              var ch, l, w;
                                                              t = t || nexttoken;
                                                              if (t.id === '(end)') {  // `~
                                                                  t = token;

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

                                                            function doFunction(i, statement) {
                                                                var f,
                                                                    oldOption = option,
                                                                    oldScope  = scope;
                                                        
                                                        

                                                          Consider simplifying this complex logical expression.
                                                          Open

                                                                      if (!left.identifier && left.id !== '.' && left.id !== '[' &&
                                                                              left.id !== '(' && left.id !== '&&' && left.id !== '||' &&
                                                                              left.id !== '?') {
                                                                          warning("Bad invocation.", left);
                                                                      }

                                                            Function warningAt has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                            Open

                                                                function warningAt(m, l, ch, a, b, c, d) {

                                                              Function errorAt has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                              Open

                                                                  function errorAt(m, l, ch, a, b, c, d) {

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

                                                                    function error(m, t, a, b, c, d) {

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

                                                                      function warning(m, t, a, b, c, d) {

                                                                    Avoid deeply nested control flow statements.
                                                                    Open

                                                                                                    if (i >= 0) {
                                                                                                        break;
                                                                                                    }

                                                                      Avoid deeply nested control flow statements.
                                                                      Open

                                                                                              if (option.newcap && (i < 'A' || i > 'Z')) {
                                                                                                  warning("A constructor name should start with an uppercase letter.",
                                                                                                      token);
                                                                                              }

                                                                        Avoid deeply nested control flow statements.
                                                                        Open

                                                                                                        if (jsonmode) {
                                                                                                            warningAt("Avoid \\v.", line, character);
                                                                                                        }

                                                                          Avoid deeply nested control flow statements.
                                                                          Open

                                                                                                  if (data.member[k] === 1) {
                                                                                                      n = '<i>' + n + '</i>';
                                                                                                  }

                                                                            Avoid deeply nested control flow statements.
                                                                            Open

                                                                                                    if (option.undef) {
                                                                                                        // Attempting to subscript a null reference will throw an
                                                                                                        // error, even within the typeof and delete operators
                                                                                                        if (!(anonname === 'typeof' || anonname === 'delete') ||
                                                                                                            (nexttoken &&

                                                                              Avoid deeply nested control flow statements.
                                                                              Open

                                                                                                  for (i = 0; i < k.length; i += 1) {
                                                                                                      predefined[k[i]] = !!a[k[i]];
                                                                                                  }

                                                                                Avoid deeply nested control flow statements.
                                                                                Open

                                                                                                                if (!nextLine()) {
                                                                                                                    errorAt("Unclosed comment.", line, character);
                                                                                                                }

                                                                                  Avoid deeply nested control flow statements.
                                                                                  Open

                                                                                                          if (!m["use strict"] && !directive["use strict"]) {
                                                                                                              warning("Missing \"use strict\" statement.");
                                                                                                          }

                                                                                    Avoid deeply nested control flow statements.
                                                                                    Open

                                                                                                            switch (s[v]) {
                                                                                                            case 'function':
                                                                                                            case 'unction':
                                                                                                                this['function'] = true;
                                                                                                                s[v] = 'closure';

                                                                                      Avoid deeply nested control flow statements.
                                                                                      Open

                                                                                                                      if (option.multistr) {
                                                                                                                          if (jsonmode) {
                                                                                                                              warningAt("Avoid EOL escapement.", line, character);
                                                                                                                          }
                                                                                                                          c = '';

                                                                                        Avoid deeply nested control flow statements.
                                                                                        Open

                                                                                                                        if (d.isDigit()) {
                                                                                                                            if (token.id !== '.') {
                                                                                                                                warningAt("Don't use extra leading zeros '{a}'.",
                                                                                                                                    line, character, t);
                                                                                                                            }

                                                                                          Avoid deeply nested control flow statements.
                                                                                          Open

                                                                                                                  if (is_own(directive, d)) {
                                                                                                                      m[d] = directive[d];
                                                                                                                  }

                                                                                            Avoid deeply nested control flow statements.
                                                                                            Open

                                                                                                                            for (;;) {
                                                                                                                                b = true;
                                                                                                                                c = s.charAt(l);
                                                                                                                                l += 1;
                                                                                                                                switch (c) {

                                                                                              Avoid deeply nested control flow statements.
                                                                                              Open

                                                                                                                  if (typeof b !== 'number' || !isFinite(b) || b <= 0 ||
                                                                                                                          Math.floor(b) !== b) {
                                                                                                                      error("Expected a small integer and instead saw '{a}'.",
                                                                                                                              v, v.value);
                                                                                                                  }

                                                                                                Avoid deeply nested control flow statements.
                                                                                                Open

                                                                                                                } else if (t.value === 'maxlen' && (o === '/*jshint' || o === '/*jslint')) {
                                                                                                                    b = +v.value;
                                                                                                                    if (typeof b !== 'number' || !isFinite(b) || b <= 0 ||
                                                                                                                            Math.floor(b) !== b) {
                                                                                                                        error("Expected a small integer and instead saw '{a}'.",

                                                                                                  Avoid deeply nested control flow statements.
                                                                                                  Open

                                                                                                                          if (left.value === 'Math') {
                                                                                                                              warning("Math is not a function.", left);
                                                                                                                          } else if (option.newcap) {
                                                                                                                              warning(
                                                                                                  "Missing 'new' prefix when invoking a constructor.", left);

                                                                                                    Avoid deeply nested control flow statements.
                                                                                                    Open

                                                                                                                            if (nexttoken.id !== ',') {
                                                                                                                                break;
                                                                                                                            }

                                                                                                      Avoid deeply nested control flow statements.
                                                                                                      Open

                                                                                                                              if (i < a.length - 1) {
                                                                                                                                  n += ', ';
                                                                                                                              }

                                                                                                        Avoid deeply nested control flow statements.
                                                                                                        Open

                                                                                                                                if (pn.id !== "(string)" && pn.id !== "(number)" &&
                                                                                                                                    pn.id !== "(regexp)" && pn.identifier !== true &&
                                                                                                                                    pn.id !== "}") {
                                                                                                                                    break;
                                                                                                                                }

                                                                                                          Avoid deeply nested control flow statements.
                                                                                                          Open

                                                                                                                                  if (v === 'unused') {
                                                                                                                                      unused.push({
                                                                                                                                          name: n,
                                                                                                                                          line: f['(line)'],
                                                                                                                                          'function': f['(name)']

                                                                                                            Avoid deeply nested control flow statements.
                                                                                                            Open

                                                                                                                                            if (jsonmode) {
                                                                                                                                                warningAt("Avoid \\x-.", line, character);
                                                                                                                                            }

                                                                                                              Avoid deeply nested control flow statements.
                                                                                                              Open

                                                                                                                                      if (l + n.length > 72) {
                                                                                                                                          o.push(m + '<br>');
                                                                                                                                          m = '    ';
                                                                                                                                          l = 1;
                                                                                                                                      }

                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                Open

                                                                                                                                                if (jsonmode) {
                                                                                                                                                    warningAt("Avoid \\'.", line, character);
                                                                                                                                                }

                                                                                                                  Avoid too many return statements within this function.
                                                                                                                  Open

                                                                                                                                                  return it('(regexp)', c);

                                                                                                                    Avoid too many return statements within this function.
                                                                                                                    Open

                                                                                                                                            return;

                                                                                                                      Avoid too many return statements within this function.
                                                                                                                      Open

                                                                                                                                                  return it('(punctuator)', t);

                                                                                                                        Avoid too many return statements within this function.
                                                                                                                        Open

                                                                                                                                                                return it('(regexp)', c);

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

                                                                                                                                      function saveSetter(name, token) {
                                                                                                                                          if (props[name] && is_own(props, name)) {
                                                                                                                                              if (props[name].basic || props[name].setter)
                                                                                                                                                  warning("Duplicate member '{a}'.", nexttoken, i);
                                                                                                                                          } else {
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3271..3281

                                                                                                                          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

                                                                                                                                      function saveGetter(name) {
                                                                                                                                          if (props[name] && is_own(props, name)) {
                                                                                                                                              if (props[name].basic || props[name].getter)
                                                                                                                                                  warning("Duplicate member '{a}'.", nexttoken, i);
                                                                                                                                          } else {
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3259..3269

                                                                                                                          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

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

                                                                                                                                  if (nexttoken.id !== ';') {
                                                                                                                                      if (token.line === nexttoken.line) {
                                                                                                                                          if (funct[v] !== 'label') {
                                                                                                                                              warning("'{a}' is not a statement label.", nexttoken, v);
                                                                                                                                          } else if (scope[v] !== funct) {
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3837..3847

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

                                                                                                                          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 (nexttoken.id !== ';') {
                                                                                                                                      if (token.line === nexttoken.line) {
                                                                                                                                          if (funct[v] !== 'label') {
                                                                                                                                              warning("'{a}' is not a statement label.", nexttoken, v);
                                                                                                                                          } else if (scope[v] !== funct) {
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3862..3874

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

                                                                                                                          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

                                                                                                                                          } else if (t.value === 'maxerr' && (o === '/*jshint' || o === '/*jslint')) {
                                                                                                                                              b = +v.value;
                                                                                                                                              if (typeof b !== 'number' || !isFinite(b) || b <= 0 ||
                                                                                                                                                      Math.floor(b) !== b) {
                                                                                                                                                  error("Expected a small integer and instead saw '{a}'.",
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 1773..1796

                                                                                                                          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

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

                                                                                                                                          } else if (t.value === 'maxlen' && (o === '/*jshint' || o === '/*jslint')) {
                                                                                                                                              b = +v.value;
                                                                                                                                              if (typeof b !== 'number' || !isFinite(b) || b <= 0 ||
                                                                                                                                                      Math.floor(b) !== b) {
                                                                                                                                                  error("Expected a small integer and instead saw '{a}'.",
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 1765..1796

                                                                                                                          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

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

                                                                                                                                      if (left.line === right.line && left.character === right.from) {
                                                                                                                                          left.from += (left.character - left.from);
                                                                                                                                          warning("Missing space after '{a}'.",
                                                                                                                                                  left, left.value);
                                                                                                                                      }
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 1955..1958

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

                                                                                                                          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 (left.character !== right.from && left.line === right.line) {
                                                                                                                                          left.from += (left.character - left.from);
                                                                                                                                          warning("Unexpected space after '{a}'.", left, left.value);
                                                                                                                                      }
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 1984..1988

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

                                                                                                                          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 (option.undef) {
                                                                                                                                                      // Attempting to subscript a null reference will throw an
                                                                                                                                                      // error, even within the typeof and delete operators
                                                                                                                                                      if (!(anonname === 'typeof' || anonname === 'delete') ||
                                                                                                                                                          (nexttoken &&
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 2670..2678

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

                                                                                                                          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 (option.undef && typeof predefined[v] !== 'boolean') {
                                                                                                                                              // Attempting to subscript a null reference will throw an
                                                                                                                                              // error, even within the typeof and delete operators
                                                                                                                                              if (!(anonname === 'typeof' || anonname === 'delete') ||
                                                                                                                                                  (nexttoken && (nexttoken.value === '.' || nexttoken.value === '['))) {
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 2709..2718

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

                                                                                                                          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 (;;) {
                                                                                                                                                                                  c = s.charAt(l);
                                                                                                                                                                                  if (c < '0' || c > '9') {
                                                                                                                                                                                      break;
                                                                                                                                                                                  }
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 1615..1622

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

                                                                                                                          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 (;;) {
                                                                                                                                                                          c = s.charAt(l);
                                                                                                                                                                          if (c < '0' || c > '9') {
                                                                                                                                                                              break;
                                                                                                                                                                          }
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 1631..1638

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

                                                                                                                          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) {
                                                                                                                                      indent += option.indent;
                                                                                                                                      if (nexttoken.from === indent + option.indent) {
                                                                                                                                          indent += option.indent;
                                                                                                                                      }
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3284..3289

                                                                                                                          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 (b) {
                                                                                                                                          indent += option.indent;
                                                                                                                                          if (nexttoken.from === indent + option.indent) {
                                                                                                                                              indent += option.indent;
                                                                                                                                          }
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3135..3140

                                                                                                                          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

                                                                                                                              infix('+++', function (left) {
                                                                                                                                  warning("Confusing pluses.");
                                                                                                                                  this.left = left;
                                                                                                                                  this.right = expression(130);
                                                                                                                                  return this;
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 2901..2906

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

                                                                                                                              infix('---', function (left) {
                                                                                                                                  warning("Confusing minuses.");
                                                                                                                                  this.left = left;
                                                                                                                                  this.right = expression(130);
                                                                                                                                  return this;
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 2887..2892

                                                                                                                          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

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

                                                                                                                                                                          if (c < ' ') {
                                                                                                                                                                              warningAt(
                                                                                                                          "Unexpected control character in regular expression.", line, from + l);
                                                                                                                                                                          } else if (c === '<') {
                                                                                                                                                                              warningAt(
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 1425..1431

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

                                                                                                                                                                  if (c < ' ') {
                                                                                                                                                                      warningAt(
                                                                                                                          "Unexpected control character in regular expression.", line, from + l);
                                                                                                                                                                  } else if (c === '<') {
                                                                                                                                                                      warningAt(
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 1532..1538

                                                                                                                          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

                                                                                                                              prefix('+++', function () {
                                                                                                                                  warning("Confusing pluses.");
                                                                                                                                  this.right = expression(150);
                                                                                                                                  this.arity = 'unary';
                                                                                                                                  return this;
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 2895..2900

                                                                                                                          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

                                                                                                                              prefix('---', function () {
                                                                                                                                  warning("Confusing minuses.");
                                                                                                                                  this.right = expression(150);
                                                                                                                                  this.arity = 'unary';
                                                                                                                                  return this;
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 2881..2886

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

                                                                                                                                  if (nexttoken.id === '=') {
                                                                                                                                      if (!option.boss)
                                                                                                                                          warning("Expected a conditional expression and instead saw an assignment.");
                                                                                                                                      advance('=');
                                                                                                                                      expression(20);
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3521..3526
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3725..3730
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3796..3801

                                                                                                                          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

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

                                                                                                                                      if (nexttoken.id === '=') {
                                                                                                                                          if (!option.boss)
                                                                                                                                              warning("Expected a conditional expression and instead saw an assignment.");
                                                                                                                                          advance('=');
                                                                                                                                          expression(20);
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3521..3526
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3584..3589
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3796..3801

                                                                                                                          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

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

                                                                                                                                          if (nexttoken.id === '=') {
                                                                                                                                              if (!option.boss)
                                                                                                                                                  warning("Expected a conditional expression and instead saw an assignment.");
                                                                                                                                              advance('=');
                                                                                                                                              expression(20);
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3521..3526
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3584..3589
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3725..3730

                                                                                                                          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

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

                                                                                                                                  if (nexttoken.id === '=') {
                                                                                                                                      if (!option.boss)
                                                                                                                                          warning("Expected a conditional expression and instead saw an assignment.");
                                                                                                                                      advance('=');
                                                                                                                                      expression(20);
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3584..3589
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3725..3730
                                                                                                                          src/extensions/default/JavaScriptQuickEdit/unittest-files/jquery-ui/external/jshint.js on lines 3796..3801

                                                                                                                          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

                                                                                                                          There are no issues that match your filters.

                                                                                                                          Category
                                                                                                                          Status