insideout10/wordlift-plugin-js

View on GitHub
app/lib/jquery-ui-1.10.3/external/jshint.js

Summary

Maintainability
F
3 mos
Test Coverage

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

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

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

Severity: Minor
Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 mo to fix

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 3884 lines of code (exceeds 25 allowed). Consider refactoring.
Open

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

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

Severity: Major
Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 2 wks to fix

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

    /*!
     * JSHint, by JSHint Community.
     *
     * This file (and this file only) is licensed under the same slightly modified
     * MIT license that JSLint is. It stops evil-doers everywhere.
    Severity: Major
    Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 wk to fix

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

          var lex = (function lex() {
              var character, from, line, s;
      
      // Private lex methods
      
      
      Severity: Major
      Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 3 days to fix

        Function token has 514 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, n;
        
                        function match(x) {
                            var r = x.exec(s), r1;
        Severity: Major
        Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 2 days to fix

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

              var itself = function (s, o, g) {
                  var a, i, k, x;
                  var optionKeys;
                  var newOptionObj = {};
          
          
          Severity: Major
          Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 day to fix

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

                function doOption() {
                    var nt = nexttoken;
                    var o  = nt.value;
                    var quotmarkValue = option.quotmark;
                    var predef = {};
            Severity: Major
            Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 5 hrs to fix

              Function string has 135 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.",
              Severity: Major
              Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 5 hrs to fix

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

                        x.nud = function () {
                            var b, f, i, p, t;
                            var props = {}; // All properties, including accessors
                
                            function saveProperty(name, token) {
                Severity: Major
                Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 4 hrs to fix

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

                      blockstmt("switch", function () {
                          var t = nexttoken,
                              g = false;
                          funct["(breakage)"] += 1;
                          advance("(");
                  Severity: Major
                  Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 4 hrs to fix

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

                            nud: function () {
                                var v = this.value,
                                    s = scope[v],
                                    f;
                    
                    
                    Severity: Major
                    Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 3 hrs to fix

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

                          function jsonValue() {
                      
                              function jsonObject() {
                                  var o = {}, t = nexttoken;
                                  advance("{");
                      Severity: Major
                      Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 3 hrs to fix

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

                            blockstmt("for", function () {
                                var s, t = nexttoken;
                                funct["(breakage)"] += 1;
                                funct["(loopage)"] += 1;
                                increaseComplexityCount();
                        Severity: Major
                        Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 3 hrs to fix

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

                              function block(ordinary, stmt, isfunc) {
                                  var a,
                                      b = inblock,
                                      old_indent = indent,
                                      m,
                          Severity: Major
                          Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 2 hrs to fix

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

                                infix("(", function (left, that) {
                                    if (prevtoken.id !== "}" && prevtoken.id !== ")") {
                                        nobreak(prevtoken, token);
                                    }
                                    nospace();
                            Severity: Major
                            Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 2 hrs to fix

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

                                  itself.data = function () {
                                      var data = {
                                          functions: [],
                                          options: option
                                      };
                              Severity: Major
                              Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 2 hrs to fix

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

                                        function it(type, value) {
                                            var i, t;
                                
                                            function checkName(name) {
                                                if (!option.proto && name === "__proto__") {
                                Severity: Major
                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 2 hrs to fix

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

                                      function statement(noindent) {
                                          var i = indent, r, s = scope, t = nexttoken;
                                  
                                          if (t.id === ";") {
                                              advance(";");
                                  Severity: Major
                                  Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 2 hrs to fix

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

                                        function expression(rbp, initial) {
                                            var left, isArray = false, isObject = false;
                                    
                                            if (nexttoken.id === "(end)")
                                                error("Unexpected early end of program.", token);
                                    Severity: Minor
                                    Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 2 hrs to fix

                                      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);
                                      Severity: Minor
                                      Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

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

                                            function assume() {
                                                if (option.couch) {
                                                    combine(predefined, couch);
                                                }
                                        
                                        
                                        Severity: Minor
                                        Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

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

                                              function directives() {
                                                  var i, p, pn;
                                          
                                                  for (;;) {
                                                      if (nexttoken.id === "(string)") {
                                          Severity: Minor
                                          Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

                                            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 (;;) {
                                            Severity: Minor
                                            Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

                                              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;
                                              
                                              
                                              Severity: Minor
                                              Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

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

                                                        function jsonObject() {
                                                            var o = {}, t = nexttoken;
                                                            advance("{");
                                                            if (nexttoken.id !== "}") {
                                                                for (;;) {
                                                Severity: Minor
                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

                                                  Function doCatch has 36 lines of code (exceeds 25 allowed). Consider refactoring.
                                                  Open

                                                          function doCatch() {
                                                              var oldScope = scope;
                                                              var e;
                                                  
                                                              advance("catch");
                                                  Severity: Minor
                                                  Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

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

                                                        function createMetrics(functionStartToken) {
                                                            return {
                                                                statementCount: 0,
                                                                nestedBlockDepth: -1,
                                                                ComplexityCount: 1,
                                                    Severity: Minor
                                                    Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

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

                                                          function addlabel(t, type, token) {
                                                              if (t === "hasOwnProperty") {
                                                                  warning("'hasOwnProperty' is a really bad name.");
                                                              }
                                                      
                                                      
                                                      Severity: Minor
                                                      Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

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

                                                            function doFunction(name, statement) {
                                                                var f;
                                                                var oldOption = option;
                                                                var oldScope  = scope;
                                                        
                                                        
                                                        Severity: Minor
                                                        Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

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

                                                              function assignop(s) {
                                                                  symbol(s, 20).exps = true;
                                                          
                                                                  return infix(s, function (left, that) {
                                                                      that.left = left;
                                                          Severity: Minor
                                                          Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

                                                            Function warning has 29 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;
                                                            Severity: Minor
                                                            Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

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

                                                                      Array.prototype.indexOf = function (searchElement /*, fromIndex */ ) {
                                                                          if (this === null || this === undefined) {
                                                                              throw new TypeError();
                                                                          }
                                                              
                                                              
                                                              Severity: Minor
                                                              Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

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

                                                                        function nextLine() {
                                                                            var at,
                                                                                match,
                                                                                tw; // trailing whitespace check
                                                                
                                                                
                                                                Severity: Minor
                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

                                                                  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);
                                                                              }
                                                                  Severity: Major
                                                                  Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 1 hr to fix

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

                                                                        function errorAt(m, l, ch, a, b, c, d) {
                                                                    Severity: Major
                                                                    Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 50 mins to fix

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

                                                                          function warningAt(m, l, ch, a, b, c, d) {
                                                                      Severity: Major
                                                                      Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 50 mins to fix

                                                                        Avoid deeply nested control flow statements.
                                                                        Open

                                                                                                        if (jsonmode) {
                                                                                                            warningAt("Avoid \\x-.", line, character);
                                                                                                        }
                                                                        Severity: Major
                                                                        Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                          Avoid deeply nested control flow statements.
                                                                          Open

                                                                                                  if (!m["use strict"] && !directive["use strict"]) {
                                                                                                      warning("Missing \"use strict\" statement.");
                                                                                                  }
                                                                          Severity: Major
                                                                          Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                            Avoid deeply nested control flow statements.
                                                                            Open

                                                                                                    switch (s[v]) {
                                                                                                    case "function":
                                                                                                    case "unction":
                                                                                                        this["function"] = true;
                                                                                                        s[v] = "closure";
                                                                            Severity: Major
                                                                            Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

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

                                                                                  function warning(m, t, a, b, c, d) {
                                                                              Severity: Minor
                                                                              Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                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 &&
                                                                                Severity: Major
                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                  Avoid deeply nested control flow statements.
                                                                                  Open

                                                                                                                  if (isDigit(d)) {
                                                                                                                      if (token.id !== ".") {
                                                                                                                          warningAt("Don't use extra leading zeros '{a}'.",
                                                                                                                              line, character, t);
                                                                                                                      }
                                                                                  Severity: Major
                                                                                  Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                    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);
                                                                                                            }
                                                                                    Severity: Major
                                                                                    Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                      Avoid deeply nested control flow statements.
                                                                                      Open

                                                                                                              if (nexttoken.id !== ",") {
                                                                                                                  break;
                                                                                                              }
                                                                                      Severity: Major
                                                                                      Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                        Avoid deeply nested control flow statements.
                                                                                        Open

                                                                                                                if (is_own(directive, d)) {
                                                                                                                    m[d] = directive[d];
                                                                                                                }
                                                                                        Severity: Major
                                                                                        Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                          Avoid deeply nested control flow statements.
                                                                                          Open

                                                                                                              if (funct["(global)"]) {
                                                                                                                  error("Option 'validthis' can't be used in a global scope.");
                                                                                                              } else {
                                                                                                                  if (v.value === "true" || v.value === "false")
                                                                                                                      obj[t.value] = v.value === "true";
                                                                                          Severity: Major
                                                                                          Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                            Avoid deeply nested control flow statements.
                                                                                            Open

                                                                                                                    if (option.newcap && (i < "A" || i > "Z") && !is_own(global, c.value)) {
                                                                                                                        warning("A constructor name should start with an uppercase letter.",
                                                                                                                            token);
                                                                                                                    }
                                                                                            Severity: Major
                                                                                            Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                              Avoid deeply nested control flow statements.
                                                                                              Open

                                                                                                                              if (n >= 0 && n <= 7 && directive["use strict"]) {
                                                                                                                                  warningAt(
                                                                                                                                  "Octal literals are not allowed in strict mode.",
                                                                                                                                  line, character);
                                                                                                                              }
                                                                                              Severity: Major
                                                                                              Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                                Avoid deeply nested control flow statements.
                                                                                                Open

                                                                                                                        if (pn.id !== "(string)" && pn.id !== "(number)" &&
                                                                                                                            pn.id !== "(regexp)" && pn.identifier !== true &&
                                                                                                                            pn.id !== "}") {
                                                                                                                            break;
                                                                                                                        }
                                                                                                Severity: Major
                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                                  Avoid deeply nested control flow statements.
                                                                                                  Open

                                                                                                                                  if (s.charAt(j - 2) === "<")
                                                                                                                                      break;
                                                                                                  Severity: Major
                                                                                                  Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                                    Avoid deeply nested control flow statements.
                                                                                                    Open

                                                                                                                            if (left.value !== token.value) {
                                                                                                                                isObject = false;
                                                                                                                            }
                                                                                                    Severity: Major
                                                                                                    Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                                      Avoid deeply nested control flow statements.
                                                                                                      Open

                                                                                                                                      if (jsonmode) {
                                                                                                                                          warningAt("Avoid \\'.", line, character);
                                                                                                                                      }
                                                                                                      Severity: Major
                                                                                                      Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                                        Avoid deeply nested control flow statements.
                                                                                                        Open

                                                                                                                                        if (jsonmode) {
                                                                                                                                            warningAt("Avoid \\v.", line, character);
                                                                                                                                        }
                                                                                                        Severity: Major
                                                                                                        Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                                          Avoid deeply nested control flow statements.
                                                                                                          Open

                                                                                                                                          if (option.multistr) {
                                                                                                                                              if (jsonmode) {
                                                                                                                                                  warningAt("Avoid EOL escapement.", line, character);
                                                                                                                                              }
                                                                                                                                              c = "";
                                                                                                          Severity: Major
                                                                                                          Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                                            Avoid deeply nested control flow statements.
                                                                                                            Open

                                                                                                                                            if (!nextLine()) {
                                                                                                                                                errorAt("Unclosed comment.", line, character);
                                                                                                                                            }
                                                                                                            Severity: Major
                                                                                                            Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                                              Avoid deeply nested control flow statements.
                                                                                                              Open

                                                                                                                                              for (;;) {
                                                                                                                                                  b = true;
                                                                                                                                                  c = s.charAt(l);
                                                                                                                                                  l += 1;
                                                                                                                                                  switch (c) {
                                                                                                              Severity: Major
                                                                                                              Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

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

                                                                                                                    function error(m, t, a, b, c, d) {
                                                                                                                Severity: Minor
                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                  Open

                                                                                                                                  } else if (t.value === "quotmark" && (o === "/*jshint")) {
                                                                                                                                      switch (v.value) {
                                                                                                                                      case "true":
                                                                                                                                          obj.quotmark = true;
                                                                                                                                          break;
                                                                                                                  Severity: Major
                                                                                                                  Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                    Open

                                                                                                                                                    if (i >= 0) {
                                                                                                                                                        break;
                                                                                                                                                    }
                                                                                                                    Severity: Major
                                                                                                                    Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 45 mins to fix

                                                                                                                      Consider simplifying this complex logical expression.
                                                                                                                      Open

                                                                                                                                      } else if (p[0] && p[0].id === "(string)" &&
                                                                                                                                             left.value === "." &&
                                                                                                                                             left.left.value === "window" &&
                                                                                                                                             (left.right === "setTimeout" ||
                                                                                                                                              left.right === "setInterval")) {
                                                                                                                      Severity: Major
                                                                                                                      Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 40 mins to fix

                                                                                                                        Avoid too many return statements within this function.
                                                                                                                        Open

                                                                                                                                                        return it("(regexp)", c);
                                                                                                                        Severity: Major
                                                                                                                        Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 30 mins to fix

                                                                                                                          Avoid too many return statements within this function.
                                                                                                                          Open

                                                                                                                                                  return;
                                                                                                                          Severity: Major
                                                                                                                          Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 30 mins to fix

                                                                                                                            Avoid too many return statements within this function.
                                                                                                                            Open

                                                                                                                                                        return it("(punctuator)", t);
                                                                                                                            Severity: Major
                                                                                                                            Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 30 mins to fix

                                                                                                                              Avoid too many return statements within this function.
                                                                                                                              Open

                                                                                                                                                                      return it("(regexp)", c);
                                                                                                                              Severity: Major
                                                                                                                              Found in app/lib/jquery-ui-1.10.3/external/jshint.js - About 30 mins to fix

                                                                                                                                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 {
                                                                                                                                Severity: Major
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 3 hrs to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 3640..3650

                                                                                                                                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 {
                                                                                                                                Severity: Major
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 3 hrs to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 3628..3638

                                                                                                                                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) {
                                                                                                                                Severity: Major
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 2 hrs to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 4301..4313

                                                                                                                                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) {
                                                                                                                                Severity: Major
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 2 hrs to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 4276..4286

                                                                                                                                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

                                                                                                                                            if (left.character !== right.from && left.line === right.line) {
                                                                                                                                                left.from += (left.character - left.from);
                                                                                                                                                warning("Unexpected space after '{a}'.", left, left.value);
                                                                                                                                            }
                                                                                                                                Severity: Major
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 1 hr to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 2252..2256

                                                                                                                                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.line === right.line && left.character === right.from) {
                                                                                                                                                left.from += (left.character - left.from);
                                                                                                                                                warning("Missing space after '{a}'.",
                                                                                                                                                        left, left.value);
                                                                                                                                            }
                                                                                                                                Severity: Major
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 1 hr to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 2220..2223

                                                                                                                                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 &&
                                                                                                                                Severity: Major
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 1 hr to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 2966..2974

                                                                                                                                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 === "["))) {
                                                                                                                                Severity: Major
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 1 hr to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 3006..3015

                                                                                                                                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;
                                                                                                                                                                                        }
                                                                                                                                Severity: Major
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 1 hr to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 1784..1791

                                                                                                                                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;
                                                                                                                                                                                }
                                                                                                                                Severity: Major
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 1 hr to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 1800..1807

                                                                                                                                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;
                                                                                                                                                }
                                                                                                                                Severity: Minor
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 50 mins to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 3438..3443

                                                                                                                                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;
                                                                                                                                            }
                                                                                                                                Severity: Minor
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 50 mins to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 3653..3658

                                                                                                                                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;
                                                                                                                                Severity: Minor
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 50 mins to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 3196..3201

                                                                                                                                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;
                                                                                                                                Severity: Minor
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 50 mins to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 3182..3187

                                                                                                                                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(
                                                                                                                                Severity: Minor
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 45 mins to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 1595..1601

                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                Tuning

                                                                                                                                This issue has a mass of 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(
                                                                                                                                Severity: Minor
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 45 mins to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 1700..1706

                                                                                                                                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 minuses.");
                                                                                                                                        this.right = expression(150);
                                                                                                                                        this.arity = "unary";
                                                                                                                                        return this;
                                                                                                                                Severity: Minor
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 40 mins to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 3176..3181

                                                                                                                                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 pluses.");
                                                                                                                                        this.right = expression(150);
                                                                                                                                        this.arity = "unary";
                                                                                                                                        return this;
                                                                                                                                Severity: Minor
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 1 other location - About 40 mins to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 3190..3195

                                                                                                                                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);
                                                                                                                                Severity: Major
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 3 other locations - About 35 mins to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 3900..3905
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 4002..4007
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 4235..4240

                                                                                                                                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);
                                                                                                                                Severity: Major
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 3 other locations - About 35 mins to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 3900..3905
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 4002..4007
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 4163..4168

                                                                                                                                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);
                                                                                                                                Severity: Major
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 3 other locations - About 35 mins to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 4002..4007
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 4163..4168
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 4235..4240

                                                                                                                                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);
                                                                                                                                Severity: Major
                                                                                                                                Found in app/lib/jquery-ui-1.10.3/external/jshint.js and 3 other locations - About 35 mins to fix
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 3900..3905
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 4163..4168
                                                                                                                                app/lib/jquery-ui-1.10.3/external/jshint.js on lines 4235..4240

                                                                                                                                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