Sign upLogin

kuasha/cosmos

View on GitHub
Star
samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js

Summary

Maintainability
F
1 yr
Test Coverage

File worker-javascript.js has 9214 lines of code (exceeds 250 allowed). Consider refactoring.
Open

"no use strict";
;(function(window) {
if (typeof window.window != "undefined" && window.document) {
    return;
}
Severity: Major
Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 3 wks to fix

    Function 3 has 4033 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    3:[function(_dereq_,module,exports){

var _        = _dereq_("underscore");
var events   = _dereq_("events");
var vars     = _dereq_("./vars.js");
    Severity: Major
    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 wks to fix

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

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

  var anonname, // The guessed name for anonymous functions.
    api, // Extension API
      Severity: Major
      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 wks to fix

        Function 4 has 1142 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        4:[function(_dereq_,module,exports){

"use strict";

var _      = _dereq_("underscore");
        Severity: Major
        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 5 days to fix

          Function 2 has 931 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          2:[function(_dereq_,module,exports){

(function() {
  var root = this;
  var previousUnderscore = root._;
          Severity: Major
          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 4 days to fix

            Function 9 has 617 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            9:[function(_dereq_,module,exports){

"use strict";

exports.reservedVars = {
            Severity: Major
            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 3 days to fix

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

                var itself = function (s, o, g) {
    var i, k, x;
    var optionKeys;
    var newOptionObj = {};
    var newIgnoredObj = {};
              Severity: Major
              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 day to fix

                Function 10 has 211 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                10:[function(_dereq_,module,exports){

function EventEmitter() {
  this._events = this._events || {};
  this._maxListeners = this._maxListeners || undefined;
                Severity: Major
                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 day to fix

                  Function 5 has 201 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  5:[function(_dereq_,module,exports){
"use strict";

var _ = _dereq_("underscore");
                  Severity: Major
                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 day to fix

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

                      function doOption() {
    var nt = state.tokens.next;
    var body = nt.body.match(/(-\s+)?[^\s,:]+(?:\s*:\s*(-\s+)?[^\s,]+)?/g);
    var predef = {};
                    Severity: Major
                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 7 hrs to fix

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

                        token: function () {
    var checks = asyncTrigger();
    var token;
                      Severity: Major
                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 6 hrs to fix

                        Function scanStringLiteral has 157 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                          scanStringLiteral: function (checks) {
    var quote = this.peek();
    if (quote !== "\"" && quote !== "'") {
      return null;
    }
                        Severity: Major
                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 6 hrs to fix

                          Function scanNumericLiteral has 146 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                            scanNumericLiteral: function () {
    var index = 0;
    var value = "";
    var length = this.input.length;
    var char = this.peek(index);
                          Severity: Major
                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 5 hrs to fix

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

                                x.nud = function (isclassdef) {
      var b, f, i, p, t, g;
      var props = {}; // All properties, including accessors
      var tag = "";
                            Severity: Major
                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 5 hrs to fix

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

                                scanRegExp: function () {
    var index = 0;
    var length = this.input.length;
    var char = this.peek();
    var value = char;
                              Severity: Major
                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 4 hrs to fix

                                Function scanPunctuator has 112 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                  scanPunctuator: function () {
    var ch1 = this.peek();
    var ch2, ch3, ch4;

    switch (ch1) {
                                Severity: Major
                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 4 hrs to fix

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

                                    blockstmt("for", function () {
    var s, t = state.tokens.next;
    var letscope = false;
    var foreachtok = null;
                                  Severity: Major
                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 4 hrs to fix

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

                                      function block(ordinary, stmt, isfunc, isfatarrow, iscase) {
    var a,
      b = inblock,
      old_indent = indent,
      m,
                                    Severity: Major
                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 4 hrs to fix

                                      Function 8 has 100 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                      8:[function(_dereq_,module,exports){
"use strict";

exports.register = function (linter) {
                                      Severity: Major
                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 4 hrs to fix

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

                                            nud: function () {
      var v = this.value;
      var s = scope[v];
      var f;
      var block;
                                        Severity: Major
                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 4 hrs to fix

                                          Function scanComments has 98 lines of code (exceeds 25 allowed). Consider refactoring.
                                          Open

                                            scanComments: function () {
    var ch1 = this.peek();
    var ch2 = this.peek(1);
    var rest = this.input.substr(2);
    var startLine = this.line;
                                          Severity: Major
                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 3 hrs to fix

                                            Function register has 98 lines of code (exceeds 25 allowed). Consider refactoring.
                                            Open

                                            exports.register = function (linter) {

  linter.on("Identifier", function style_scanProto(data) {
    if (linter.getOption("proto")) {
      return;
                                            Severity: Major
                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 3 hrs to fix

                                              Function scanIdentifier has 97 lines of code (exceeds 25 allowed). Consider refactoring.
                                              Open

                                                scanIdentifier: function () {
    var id = "";
    var index = 0;
    var type, char;
                                              Severity: Major
                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 3 hrs to fix

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

                                                  blockstmt("switch", function () {
    var t = state.tokens.next;
    var g = false;
    var noindent = false;
                                                Severity: Major
                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 3 hrs to fix

                                                  Function arrayComprehension has 82 lines of code (exceeds 25 allowed). Consider refactoring.
                                                  Open

                                                    var arrayComprehension = function () {
    var CompArray = function () {
      this.mode = "use";
      this.variables = [];
    };
                                                  Severity: Major
                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 3 hrs to fix

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

                                                      function assume() {
    if (state.option.esnext) {
      combine(predefined, vars.newEcmaIdentifiers);
    }
                                                    Severity: Major
                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 3 hrs to fix

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

                                                        function jsonValue() {
    function jsonObject() {
      var o = {}, t = state.tokens.next;
      advance("{");
      if (state.tokens.next.id !== "}") {
                                                      Severity: Major
                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 3 hrs to fix

                                                        Function functionparams has 77 lines of code (exceeds 25 allowed). Consider refactoring.
                                                        Open

                                                          function functionparams(parsed) {
    var curr, next;
    var params = [];
    var ident;
    var tokens = [];
                                                        Severity: Major
                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 3 hrs to fix

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

                                                            function statement() {
    var values;
    var i = indent, r, s = scope, t = state.tokens.next;

    if (t.id === ";") {
                                                          Severity: Major
                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 3 hrs to fix

                                                            Function letstatement has 70 lines of code (exceeds 25 allowed). Consider refactoring.
                                                            Open

                                                              var letstatement = stmt("let", function (prefix) {
    var tokens, lone, value, letblock;

    if (!state.option.inESNext()) {
      warning("W104", state.tokens.curr, "let");
                                                            Severity: Major
                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

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

                                                                itself.data = function () {
    var data = {
      functions: [],
      options: state.option
    };
                                                              Severity: Major
                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

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

                                                                  function expression(rbp, initial) {
    var left, isArray = false, isObject = false, isLetExpr = false;
    if (!initial && state.tokens.next.value === "let" && peek(0).value === "(") {
      if (!state.option.inMoz(true)) {
        warning("W118", state.tokens.next, "let expressions");
                                                                Severity: Major
                                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

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

                                                                    infix("(", function (left, that) {
    if (state.option.immed && left && !left.immed && left.id === "function") {
      warning("W062");
    }
                                                                  Severity: Major
                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

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

                                                                      var eq = function(a, b, aStack, bStack) {
    if (a === b) return a !== 0 || 1 / a == 1 / b;
    if (a == null || b == null) return a === b;
    if (a instanceof _) a = a._wrapped;
    if (b instanceof _) b = b._wrapped;
                                                                    Severity: Major
                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

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

                                                                        var conststatement = stmt("const", function (prefix) {
    var tokens;
    var value;
    var lone; // State variable to know if it is a lone identifier, or a destructuring statement.
                                                                      Severity: Major
                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

                                                                        Function onChange has 55 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                        Open

                                                                            this.onChange = function(e) {
        var delta = e.data;
        var range = delta.range;

        if (range.start.row == range.end.row && range.start.row != this.row)
                                                                        Severity: Major
                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

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

                                                                            function addlabel(name, opts) {
    opts = opts || {};

    var type  = opts.type;
    var token = opts.token;
                                                                          Severity: Major
                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

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

                                                                              function assignop(s, f, p) {
    var x = infix(s, typeof f === "function" ? f : function (left, that) {
      that.left = left;

      if (left) {
                                                                            Severity: Major
                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

                                                                              Function destructuringExpression has 55 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                              Open

                                                                                function destructuringExpression() {
    var id, ids;
    var identifiers = [];
    if (!state.option.inESNext()) {
      warning("W104", state.tokens.curr, "destructuring expression");
                                                                              Severity: Major
                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

                                                                                Function onUpdate has 54 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                Open

                                                                                    this.onUpdate = function() {
        var value = this.doc.getValue();
        value = value.replace(/^#!.*\n/, "\n");
        if (!value) {
            this.sender.emit("jslint", []);
                                                                                Severity: Major
                                                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

                                                                                  Function blockScope has 54 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                  Open

                                                                                    var blockScope = function () {
    var _current = {};
    var _variables = [_current];

    function _checkBlockLabels() {
                                                                                  Severity: Major
                                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

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

                                                                                      stmt("export", function () {
    if (!state.option.inESNext()) {
      warning("W119", state.tokens.curr, "export");
    }
                                                                                    Severity: Major
                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

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

                                                                                        function advance(id, t) {
    switch (state.tokens.curr.id) {
    case "(number)":
      if (state.tokens.next.id === ".") {
        warning("W005", state.tokens.curr);
                                                                                      Severity: Major
                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

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

                                                                                          var varstatement = stmt("var", function (prefix) {
    var tokens, lone, value;

    this.first = [];
    for (;;) {
                                                                                        Severity: Major
                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

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

                                                                                              var x = infix(s, typeof f === "function" ? f : function (left, that) {
      that.left = left;

      if (left) {
        if (state.option.freeze) {
                                                                                          Severity: Minor
                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 2 hrs to fix

                                                                                            Function commentToken has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                            Open

                                                                                                function commentToken(label, body, opt) {
      var special = ["jshint", "jslint", "members", "member", "globals", "global", "exported"];
      var isSpecial = false;
      var value = label + body;
      var commentType = "plain";
                                                                                            Severity: Minor
                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

                                                                                              Function emit has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                              Open

                                                                                              EventEmitter.prototype.emit = function(type) {
  var er, handler, len, args, i, listeners;

  if (!this._events)
    this._events = {};
                                                                                              Severity: Minor
                                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

                                                                                                Function comma has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                Open

                                                                                                  function comma(opts) {
    opts = opts || {};

    if (!opts.peek) {
      nobreakcomma(state.tokens.curr, state.tokens.next);
                                                                                                Severity: Minor
                                                                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

                                                                                                  Function splice has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                          Array.prototype.splice = function(pos, removeCount){
            var length = this.length;
            if (pos > 0) {
                if (pos > length)
                    pos = length;
                                                                                                  Severity: Minor
                                                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

                                                                                                    Function comprehensiveArrayExpression has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                    Open

                                                                                                      function comprehensiveArrayExpression() {
    var res = {};
    res.exps = true;
    funct["(comparray)"].stack();
    var reversed = false;
                                                                                                    Severity: Minor
                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                          var create = function (type, value, isProperty) {
      var obj;

      if (type !== "(endline)" && type !== "(end)") {
        this.prereg = false;
                                                                                                      Severity: Minor
                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                          stmt("import", function () {
    if (!state.option.inESNext()) {
      warning("W119", state.tokens.curr, "import");
    }
                                                                                                        Severity: Minor
                                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                            function directives() {
    var i, p, pn;

    for (;;) {
      if (state.tokens.next.id === "(string)") {
                                                                                                          Severity: Minor
                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                              nextLine: function () {
    var char;

    if (this.line >= this.getLines().length) {
      return false;
                                                                                                            Severity: Minor
                                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

                                                                                                              Function template has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                              Open

                                                                                                                _.template = function(text, data, settings) {
    var render;
    settings = _.defaults({}, settings, _.templateSettings);
    var matcher = new RegExp([
      (settings.escape || noMatch).source,
                                                                                                              Severity: Minor
                                                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                  function doFunction(name, statement, generator, fatarrowparams) {
    var f;
    var oldOption = state.option;
    var oldIgnored = state.ignored;
    var oldScope  = scope;
                                                                                                                Severity: Minor
                                                                                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.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 samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                      function warning(code, t, a, b, c, d) {
    var ch, l, w, msg;

    if (/^W\d{3}$/.test(code)) {
      if (state.ignored[code])
                                                                                                                    Severity: Minor
                                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                              check: function (v) {
          if (!_current) {
            return;
          }
          if (_current && _current.mode === "use") {
                                                                                                                      Severity: Minor
                                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                        window.define = function(id, deps, factory) {
    if (arguments.length == 2) {
        factory = deps;
        if (typeof id != "string") {
            deps = id;
                                                                                                                        Severity: Minor
                                                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                            scanTemplateLiteral: function () {
    if (!state.option.esnext || this.peek() !== "`") {
      return null;
    }
                                                                                                                          Severity: Minor
                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                                function jsonObject() {
      var o = {}, t = state.tokens.next;
      advance("{");
      if (state.tokens.next.id !== "}") {
        for (;;) {
                                                                                                                            Severity: Minor
                                                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

                                                                                                                              Function removeListener has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                              Open

                                                                                                                              EventEmitter.prototype.removeListener = function(type, listener) {
  var list, position, length, i;

  if (!isFunction(listener))
    throw TypeError('listener must be a function');
                                                                                                                              Severity: Minor
                                                                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

                                                                                                                                Function functor has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                Open

                                                                                                                                  function functor(name, token, scope, overwrites) {
    var funct = {
      "(name)"      : name,
      "(breakage)"  : 0,
      "(loopage)"   : 0,
                                                                                                                                Severity: Minor
                                                                                                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

                                                                                                                                  Function addListener has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                  Open

                                                                                                                                  EventEmitter.prototype.addListener = function(type, listener) {
  var m;

  if (!isFunction(listener))
    throw TypeError('listener must be a function');
                                                                                                                                  Severity: Minor
                                                                                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

                                                                                                                                    Function reduce has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                    Open

                                                                                                                                        Array.prototype.reduce = function reduce(fun /*, initial*/) {
        var object = toObject(this),
            self = splitString && _toString(this) == "[object String]" ?
                this.split("") :
                object,
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                                        var lookupBlockType = function () {
    var pn, pn1;
    var i = -1;
    var bracketStack = 0;
    var ret = {};
                                                                                                                                      Severity: Minor
                                                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                                          function createMetrics(functionStartToken) {
    return {
      statementCount: 0,
      nestedBlockDepth: -1,
      ComplexityCount: 1,
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                                              Array.prototype.reduceRight = function reduceRight(fun /*, initial*/) {
        var object = toObject(this),
            self = splitString && _toString(this) == "[object String]" ?
                this.split("") :
                object,
                                                                                                                                          Severity: Minor
                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                                                Object.defineProperty = function defineProperty(object, property, descriptor) {
        if ((typeof object != "object" && typeof object != "function") || object === null)
            throw new TypeError(ERR_NON_OBJECT_TARGET + object);
        if ((typeof descriptor != "object" && typeof descriptor != "function") || descriptor === null)
            throw new TypeError(ERR_NON_OBJECT_DESCRIPTOR + descriptor);
                                                                                                                                            Severity: Minor
                                                                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                                                  Function.prototype.bind = function bind(that) { // .length is 1
        var target = this;
        if (typeof target != "function") {
            throw new TypeError("Function.prototype.bind called on incompatible " + target);
        }
                                                                                                                                              Severity: Minor
                                                                                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                                                EventEmitter.prototype.removeAllListeners = function(type) {
  var key, listeners;

  if (!this._events)
    return this;
                                                                                                                                                Severity: Minor
                                                                                                                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                                                    _.debounce = function(func, wait, immediate) {
    var timeout, args, context, timestamp, result;

    var later = function() {
      var last = _.now() - timestamp;
                                                                                                                                                  Severity: Minor
                                                                                                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                                                      _.throttle = function(func, wait, options) {
    var context, args, result;
    var timeout = null;
    var previous = 0;
    options || (options = {});
                                                                                                                                                    Severity: Minor
                                                                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                                                      exports.delayedCall = function(fcn, defaultTimeout) {
    var timer = null;
    var callback = function() {
        timer = null;
        fcn();
                                                                                                                                                      Severity: Minor
                                                                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

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

                                                                                                                                                          next: function (checks) {
    this.from = this.char;
    var start;
    if (/\s/.test(this.peek())) {
      start = this.char;
                                                                                                                                                        Severity: Minor
                                                                                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 1 hr to fix

                                                                                                                                                          Consider simplifying this complex logical expression.
                                                                                                                                                          Open

                                                                                                                                                              if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
                             _.isFunction(bCtor) && (bCtor instanceof bCtor))
                        && ('constructor' in a && 'constructor' in b)) {
      return false;
    }
                                                                                                                                                          Severity: Major
                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.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("W067", left);
      }
                                                                                                                                                            Severity: Major
                                                                                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.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 samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.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 samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 50 mins to fix

                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                  Open

                                                                                                                                                                              if (!(anonname === "typeof" || anonname === "delete") ||
              (state.tokens.next &&
                (state.tokens.next.value === "." || state.tokens.next.value === "["))) {

              isundef(funct, "W117", state.tokens.curr, v);
                                                                                                                                                                  Severity: Major
                                                                                                                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                    Open

                                                                                                                                                                              } else if (!isclassdef) {
            advance(":");
            expression(10);
          }
                                                                                                                                                                    Severity: Major
                                                                                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                                      Open

                                                                                                                                                                                  } else if (start.row !== end.row && start.row < row) {
                if (end.row === row)
                    column = Math.max(0, column - end.column) + start.column;
                row -= (end.row - start.row);
            } else if (end.row === row) {
                                                                                                                                                                      Severity: Major
                                                                                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                                        Open

                                                                                                                                                                                        } else if (tailNewPos > tailOldPos) { // case B
                    for (i = tailCount; i--; ) {
                        this[tailNewPos+i] = this[tailOldPos+i];
                    }
                } // else, add == remove (nothing to do)
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                                          Open

                                                                                                                                                                                    if (!m["use strict"] && !state.directive["use strict"]) {
            warning("E007");
          }
                                                                                                                                                                          Severity: Major
                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                                            Open

                                                                                                                                                                                        if (start.row <= row) {
                if (end.row <= row)
                    row -= end.row - start.row;
                else {
                    row = start.row;
                                                                                                                                                                            Severity: Major
                                                                                                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

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

                                                                                                                                                                                function warning(code, t, a, b, c, d) {
                                                                                                                                                                              Severity: Minor
                                                                                                                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.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 samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                                  Open

                                                                                                                                                                                              if (left.value !== state.tokens.curr.value) {
              isObject = false;
            }
                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                                    Open

                                                                                                                                                                                                if (!funct["(comparray)"].check(v)) {
              isundef(funct, "W117", state.tokens.curr, v);
            }
                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                                                      Open

                                                                                                                                                                                                  if (isIdentifierStart(char)) {
              return null;
            }
                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                                                        Open

                                                                                                                                                                                                    if (_.has(state.directive, d)) {
              m[d] = state.directive[d];
            }
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                                                          Open

                                                                                                                                                                                                      if (isIdentifierStart(char)) {
              return null;
            }
                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                                                            Open

                                                                                                                                                                                                      if (funct[left.value] === "exception") {
            warning("W022", left);
          }
                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                                                              Open

                                                                                                                                                                                                        for (d in state.directive) {
            if (_.has(state.directive, d)) {
              m[d] = state.directive[d];
            }
          }
                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.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 samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.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 samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                                                    Open

                                                                                                                                                                                                                if (state.option.newcap && (i < "A" || i > "Z") && !_.has(global, c.value)) {
              warning("W055", state.tokens.curr);
            }
                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                                                                      Open

                                                                                                                                                                                                                          for (var i = 0; i < tailCount; ++i) {
                        this[tailNewPos+i] = this[tailOldPos+i];
                    }
                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                                                                        Open

                                                                                                                                                                                                                            for (i = 0; i < add; ++i) {
                        this[pos+i] = insert[i];
                    }
                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                                                                          Open

                                                                                                                                                                                                                      if (left.value === "Math") {
              warning("W063", left);
            } else if (state.option.newcap) {
              warning("W064", left);
            }
                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                                                                            Open

                                                                                                                                                                                                                      } else if (!left.left) {
            warning("E031", that);
          } else if (left.left.value === "arguments" && !state.directive["use strict"]) {
            warning("E031", that);
          }
                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                                                                              Open

                                                                                                                                                                                                                        } else if (curr.value !== ",") {
            params.push(curr.value);
            addlabel(curr.value, { type: "unused", token: curr });
          }
                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                                                                                                Open

                                                                                                                                                                                                                            if ((state.option.latedef === true && _.contains([funct[name], type], "unction")) ||
                !_.contains([funct[name], type], "unction")) {
              warning("W003", state.tokens.next, name);
            }
                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                              if (!m["use strict"] && !state.directive["use strict"]) {
              warning("E007");
            }
                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                if (state.tokens.next.id !== ",") {
              break;
            }
                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                  if (!state.option.inESNext()) {
              warning("W104", curr, "spread/rest operator");
            }
                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                    if (!state.option.inESNext()) {
              warning("W104", state.tokens.curr, "concise methods");
            }
                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                        if (t && funct[t.value] === "const") {
                error("E013", t, t.value);
              }
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                        if (!state.option.inESNext()) {
              warning("W104", state.tokens.next, "generator functions");
            }
                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                          if (!isHexDigit(char)) {
              break;
            }
                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                if (end.column >= column)
                    column = start.column;
                else
                    column = Math.max(0, column - (end.column - start.column));
                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                              if (!reg.fallsThrough.test(state.lines[state.tokens.next.line - 2])) {
              warning("W086", state.tokens.curr, "default");
            }
                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (isDecimalDigit(char)) {
              bad = true;
            } else if (!isOctalDigit(char)) {
              break;
            }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 45 mins to fix

                                                                                                                                                                                                                                      Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                            if (state.option.inMoz(true) && state.tokens.next.id !== ")" &&
          (prev.lbp > 30 || (!prev.assign && !isEndOfExpr()) || prev.id === "yield")) {
        error("E050", this);
      }
                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 40 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 samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 40 mins to fix

                                                                                                                                                                                                                                          Function onerror has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                          window.onerror = function(message, file, line, col, err) {
                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 35 mins to fix

                                                                                                                                                                                                                                            Function block has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                              function block(ordinary, stmt, isfunc, isfatarrow, iscase) {
                                                                                                                                                                                                                                            Severity: Minor
                                                                                                                                                                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 35 mins to fix

                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                  return -1;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                    return true;
                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                            return;
                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                              return;
                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                            return {
        type: Token.Punctuator,
        value: ">>="
      };
                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                              return null;
                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                              return {
      type: Token.NumericLiteral,
      value: value,
      base: 10,
      isMalformed: !isFinite(value)
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                      return;
                                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                  return val;
                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                      return {
        type: Token.Punctuator,
        value: ch1
      };
                                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                                          return {
          type: Token.Punctuator,
          value: "/="
        };
                                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                        return null;
                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                                                return {
            id: '(comment)',
            value: token.value,
            body: token.body,
            type: token.commentType,
                                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                                        return 0;
                                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                                    return;
                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                                  return {
        type: Token.Punctuator,
        value: "<<="
      };
                                                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                                          return column <= this.end.column ? 0 : 1;
                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                                              return null;
                                                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                                                            return;
                                                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                            return null;
                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                                                            return {
        type: Token.Punctuator,
        value: "/"
      };
                                                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                                              return commentToken("/*", body, { isMultiline: true });
                                                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                                                    return {
            type: Token.NumericLiteral,
            value: value,
            base: 8,
            isMalformed: false
                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                                                      return;
                                                                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                                                    return false;
                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                                                      return {
        type: Token.Punctuator,
        value: "!=="
      };
                                                                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                                                                            return;
                                                                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                return true;
                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                                                                                return;
                                                                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                                                                        return -1;
                                                                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                                                                          return 42;
                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                                                                    return {
          type: Token.Punctuator,
          value: ch1 + ch2
        };
                                                                                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                                                                    return null;
                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                                                                        return null;
                                                                                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                                                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                                                                                        return true;
                                                                                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                          if (aStack[length] == a) return bStack[length] == b;
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                                                                                                  return void error("E002", nt);
                                                                                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                                                                              return {
        type: Token.Punctuator,
        value: ch1 + ch2
      };
                                                                                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                                                                              return result;
                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                                                                                return r;
                                                                                                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                                                                                                            Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                                                                                          return;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                                                                                          return false;
                                                                                                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                                                                                                Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                                                                                                          return 0;
                                                                                                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                                                                                                  Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                                              return;
                                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                                    Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                                                                                                            return {
        type: Token.Punctuator,
        value: ">>>"
      };
                                                                                                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                                                                                                      Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                                                                                              return {
        type: Token.Punctuator,
        value: ch1 + ch2
      };
                                                                                                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                                                                                                        Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js - About 30 mins to fix

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

                                                                                                                                                                                                                                                                                                                                          3:[function(_dereq_,module,exports){

var _        = _dereq_("underscore");
var events   = _dereq_("events");
var vars     = _dereq_("./vars.js");
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 9 mos to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2302..6938

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                          4:[function(_dereq_,module,exports){

"use strict";

var _      = _dereq_("underscore");
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 mos to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 6939..8280

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

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

                                                                                                                                                                                                                                                                                                                                          define("ace/lib/es5-shim",["require","exports","module"], function(require, exports, module) {

function Empty() {}

if (!Function.prototype.bind) {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 6 other locations - About 1 mo to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-coffee.js on lines 6894..7589
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-css.js on lines 7692..8387
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-html.js on lines 10822..11517
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-json.js on lines 1613..2308
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-lua.js on lines 2849..3544
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-php.js on lines 6242..6937

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

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

                                                                                                                                                                                                                                                                                                                                          define("ace/document",["require","exports","module","ace/lib/oop","ace/lib/event_emitter","ace/range","ace/anchor"], function(require, exports, module) {
"use strict";

var oop = require("./lib/oop");
var EventEmitter = require("./lib/event_emitter").EventEmitter;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 6 other locations - About 3 wks to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-coffee.js on lines 726..1083
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-css.js on lines 913..1270
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-html.js on lines 913..1270
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-json.js on lines 726..1083
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-lua.js on lines 726..1083
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-php.js on lines 726..1083

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                          9:[function(_dereq_,module,exports){

"use strict";

exports.reservedVars = {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 8670..9314

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

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

                                                                                                                                                                                                                                                                                                                                          define("ace/range",["require","exports","module"], function(require, exports, module) {
"use strict";
var comparePoints = function(p1, p2) {
    return p1.row - p2.row || p1.column - p2.column;
};
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 6 other locations - About 2 wks to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-coffee.js on lines 338..575
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-css.js on lines 525..762
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-html.js on lines 525..762
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-json.js on lines 338..575
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-lua.js on lines 338..575
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-php.js on lines 338..575

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

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

                                                                                                                                                                                                                                                                                                                                          ;(function(window) {
if (typeof window.window != "undefined" && window.document) {
    return;
}
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 13 other locations - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-coffee.js on lines 2..182
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-css.js on lines 2..182
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-html.js on lines 2..182
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2..182
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-json.js on lines 2..182
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-lua.js on lines 2..182
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-php.js on lines 2..182
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-coffee.js on lines 2..182
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-css.js on lines 2..182
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-html.js on lines 2..182
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-json.js on lines 2..182
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-lua.js on lines 2..182
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-php.js on lines 2..182

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 1584.

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

                                                                                                                                                                                                                                                                                                                                          define("ace/anchor",["require","exports","module","ace/lib/oop","ace/lib/event_emitter"], function(require, exports, module) {
"use strict";

var oop = require("./lib/oop");
var EventEmitter = require("./lib/event_emitter").EventEmitter;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 6 other locations - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-coffee.js on lines 577..724
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-css.js on lines 764..911
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-html.js on lines 764..911
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-json.js on lines 577..724
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-lua.js on lines 577..724
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-php.js on lines 577..724

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

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

                                                                                                                                                                                                                                                                                                                                          define("ace/lib/lang",["require","exports","module"], function(require, exports, module) {
"use strict";

exports.last = function(a) {
    return a[a.length - 1];
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 6 other locations - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-coffee.js on lines 1085..1270
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-css.js on lines 212..397
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-html.js on lines 212..397
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-json.js on lines 1085..1270
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-lua.js on lines 1085..1270
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-php.js on lines 1085..1270

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

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

                                                                                                                                                                                                                                                                                                                                          define("ace/lib/event_emitter",["require","exports","module"], function(require, exports, module) {
"use strict";

var EventEmitter = {};
var stopPropagation = function() { this.propagationStopped = true; };
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 6 other locations - About 6 days to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-coffee.js on lines 212..336
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-css.js on lines 399..523
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-html.js on lines 399..523
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-json.js on lines 212..336
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-lua.js on lines 212..336
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-php.js on lines 212..336

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                          5:[function(_dereq_,module,exports){
"use strict";

var _ = _dereq_("underscore");
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 6 days to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 8281..8494

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                          define("ace/mode/javascript_worker",["require","exports","module","ace/lib/oop","ace/worker/mirror","ace/mode/javascript/jshint"], function(require, exports, module) {
"use strict";

var oop = require("../lib/oop");
var Mirror = require("../worker/mirror").Mirror;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 5 days to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 9576..9722

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                          8:[function(_dereq_,module,exports){
"use strict";

exports.register = function (linter) {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 5 days to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 8545..8669

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

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            var eq = function(a, b, aStack, bStack) {
    if (a === b) return a !== 0 || 1 / a == 1 / b;
    if (a == null || b == null) return a === b;
    if (a instanceof _) a = a._wrapped;
    if (b instanceof _) b = b._wrapped;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 4 days to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1999..2059

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.template = function(text, data, settings) {
    var render;
    settings = _.defaults({}, settings, _.templateSettings);
    var matcher = new RegExp([
      (settings.escape || noMatch).source,
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2212..2259

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

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

                                                                                                                                                                                                                                                                                                                                          define("ace/worker/mirror",["require","exports","module","ace/document","ace/lib/lang"], function(require, exports, module) {
"use strict";

var Document = require("../document").Document;
var lang = require("../lib/lang");
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 6 other locations - About 2 days to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-coffee.js on lines 1272..1319
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-css.js on lines 1272..1319
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-html.js on lines 1272..1319
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-json.js on lines 1272..1319
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-lua.js on lines 1272..1319
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-php.js on lines 1272..1319

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.throttle = function(func, wait, options) {
    var context, args, result;
    var timeout = null;
    var previous = 0;
    options || (options = {});
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1824..1852

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
    var initial = arguments.length > 2;
    if (obj == null) obj = [];
    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
      if (context) iterator = _.bind(iterator, context);
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1434..1457

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.debounce = function(func, wait, immediate) {
    var timeout, args, context, timestamp, result;

    var later = function() {
      var last = _.now() - timestamp;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1853..1884

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            var each = _.each = _.forEach = function(obj, iterator, context) {
    if (obj == null) return obj;
    if (nativeForEach && obj.forEach === nativeForEach) {
      obj.forEach(iterator, context);
    } else if (obj.length === +obj.length) {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1389..1404

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.bind = function(func, context) {
    var args, bound;
    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
    if (!_.isFunction(func)) throw new TypeError;
    args = slice.call(arguments, 2);
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1776..1790

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
    var initial = arguments.length > 2;
    if (obj == null) obj = [];
    if (nativeReduce && obj.reduce === nativeReduce) {
      if (context) iterator = _.bind(iterator, context);
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1416..1433

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                          7:[function(_dereq_,module,exports){
"use strict";

var state = {
  syntax: {},
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 8515..8544

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                          1:[function(_dereq_,module,exports){
var identifierStartTable = [];

for (var i = 0; i < 128; i++) {
  identifierStartTable[i] =
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1323..1348

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.indexOf = function(array, item, isSorted) {
    if (array == null) return -1;
    var i = 0, length = array.length;
    if (isSorted) {
      if (typeof isSorted == 'number') {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1732..1746

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.sortBy = function(obj, iterator, context) {
    iterator = lookupIterator(iterator);
    return _.pluck(_.map(obj, function(value, index, list) {
      return {
        value: value,
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1576..1593

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.uniq = _.unique = function(array, isSorted, iterator, context) {
    if (_.isFunction(isSorted)) {
      context = iterator;
      iterator = isSorted;
      isSorted = false;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1680..1696

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

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

                                                                                                                                                                                                                                                                                                                                          define("ace/lib/oop",["require","exports","module"], function(require, exports, module) {
"use strict";

exports.inherits = function(ctor, superCtor) {
    ctor.super_ = superCtor;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 6 other locations - About 7 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-coffee.js on lines 184..210
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-css.js on lines 184..210
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-html.js on lines 184..210
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-json.js on lines 184..210
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-lua.js on lines 184..210
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src/worker-php.js on lines 184..210

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 179.

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.max = function(obj, iterator, context) {
    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
      return Math.max.apply(Math, obj);
    }
    var result = -Infinity, lastComputed = -Infinity;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1525..1538

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 170.

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.min = function(obj, iterator, context) {
    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
      return Math.min.apply(Math, obj);
    }
    var result = Infinity, lastComputed = Infinity;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1539..1552

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.partial = function(func) {
    var boundArgs = slice.call(arguments, 1);
    return function() {
      var position = 0;
      var args = boundArgs.slice();
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1791..1802

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 164.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            _.range = function(start, stop, step) {
    if (arguments.length <= 1) {
      stop = start || 0;
      start = 0;
    }
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1757..1774

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

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            var any = _.some = _.any = function(obj, predicate, context) {
    predicate || (predicate = _.identity);
    var result = false;
    if (obj == null) return result;
    if (nativeSome && obj.some === nativeSome) return obj.some(predicate, context);
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1492..1501

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.every = _.all = function(obj, predicate, context) {
    predicate || (predicate = _.identity);
    var result = true;
    if (obj == null) return result;
    if (nativeEvery && obj.every === nativeEvery) return obj.every(predicate, context);
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1482..1491

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            var flatten = function(input, shallow, output) {
    if (shallow && _.every(input, _.isArray)) {
      return concat.apply(output, input);
    }
    each(input, function(value) {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1654..1666

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.lastIndexOf = function(array, item, from) {
    if (array == null) return -1;
    var hasIndex = from != null;
    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
      return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1747..1756

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.object = function(list, values) {
    if (list == null) return {};
    var result = {};
    for (var i = 0, length = list.length; i < length; i++) {
      if (values) {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1720..1731

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.sortedIndex = function(array, obj, iterator, context) {
    iterator = lookupIterator(iterator);
    var value = iterator.call(context, obj);
    var low = 0, high = array.length;
    while (low < high) {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1614..1623

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
    var method = ArrayProto[name];
    _.prototype[name] = function() {
      var obj = this._wrapped;
      method.apply(obj, arguments);
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2267..2275

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.mixin = function(obj) {
    each(_.functions(obj), function(name) {
      var func = _[name] = obj[name];
      _.prototype[name] = function() {
        var args = [this._wrapped];
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2180..2189

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.filter = _.select = function(obj, predicate, context) {
    var results = [];
    if (obj == null) return results;
    if (nativeFilter && obj.filter === nativeFilter) return obj.filter(predicate, context);
    each(obj, function(value, index, list) {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1468..1476

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.sample = function(obj, n, guard) {
    if (n == null || guard) {
      if (obj.length !== +obj.length) obj = _.values(obj);
      return obj[_.random(obj.length - 1)];
    }
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1564..1570

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                          6:[function(_dereq_,module,exports){

"use string";
exports.unsafeString =
  /@cc|<\/?|script|\]\s*\]|<\s*!|&lt/i;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 8495..8514

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.map = _.collect = function(obj, iterator, context) {
    var results = [];
    if (obj == null) return results;
    if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
    each(obj, function(value, index, list) {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1405..1413

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            var
    nativeForEach      = ArrayProto.forEach,
    nativeMap          = ArrayProto.map,
    nativeReduce       = ArrayProto.reduce,
    nativeReduceRight  = ArrayProto.reduceRight,
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1362..1374

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.zip = function() {
    var length = _.max(_.pluck(arguments, 'length').concat(0));
    var results = new Array(length);
    for (var i = 0; i < length; i++) {
      results[i] = _.pluck(arguments, '' + i);
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1712..1719

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.pairs = function(obj) {
    var keys = _.keys(obj);
    var length = keys.length;
    var pairs = new Array(length);
    for (var i = 0; i < length; i++) {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1931..1939

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.memoize = function(func, hasher) {
    var memo = {};
    hasher || (hasher = _.identity);
    return function() {
      var key = hasher.apply(this, arguments);
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1809..1816

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.shuffle = function(obj) {
    var rand;
    var index = 0;
    var shuffled = [];
    each(obj, function(value) {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1553..1563

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.values = function(obj) {
    var keys = _.keys(obj);
    var length = keys.length;
    var values = new Array(length);
    for (var i = 0; i < length; i++) {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1922..1930

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.invert = function(obj) {
    var result = {};
    var keys = _.keys(obj);
    for (var i = 0, length = keys.length; i < length; i++) {
      result[obj[keys[i]]] = keys[i];
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1940..1947

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.compose = function() {
    var funcs = arguments;
    return function() {
      var args = arguments;
      for (var i = funcs.length - 1; i >= 0; i--) {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1898..1907

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.omit = function(obj) {
    var copy = {};
    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
    for (var key in obj) {
      if (!_.contains(keys, key)) copy[key] = obj[key];
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1973..1980

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.toArray = function(obj) {
    if (!obj) return [];
    if (_.isArray(obj)) return slice.call(obj);
    if (obj.length === +obj.length) return _.map(obj, _.identity);
    return _.values(obj);
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1624..1629

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 95.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            _.bindAll = function(obj) {
    var funcs = slice.call(arguments, 1);
    if (funcs.length === 0) throw new Error('bindAll must be passed function names');
    each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
    return obj;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1803..1808

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.isEmpty = function(obj) {
    if (obj == null) return true;
    if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
    for (var key in obj) if (_.has(obj, key)) return false;
    return true;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2063..2068

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.defaults = function(obj) {
    each(slice.call(arguments, 1), function(source) {
      if (source) {
        for (var prop in source) {
          if (obj[prop] === void 0) obj[prop] = source[prop];
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1981..1990

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.first = _.head = _.take = function(array, n, guard) {
    if (array == null) return void 0;
    if ((n == null) || guard) return array[0];
    if (n < 0) return [];
    return slice.call(array, 0, n);
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1634..1639

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.contains = _.include = function(obj, target) {
    if (obj == null) return false;
    if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
    return any(obj, function(value) {
      return value === target;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1502..1508

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.keys = function(obj) {
    if (!_.isObject(obj)) return [];
    if (nativeKeys) return nativeKeys(obj);
    var keys = [];
    for (var key in obj) if (_.has(obj, key)) keys.push(key);
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1915..1921

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.pick = function(obj) {
    var copy = {};
    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
    each(keys, function(key) {
      if (key in obj) copy[key] = obj[key];
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1965..1972

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.intersection = function(array) {
    var rest = slice.call(arguments, 1);
    return _.filter(_.uniq(array), function(item) {
      return _.every(rest, function(other) {
        return _.contains(other, item);
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1700..1707

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.invoke = function(obj, method) {
    var args = slice.call(arguments, 2);
    var isFunc = _.isFunction(method);
    return _.map(obj, function(value) {
      return (isFunc ? method : value[method]).apply(value, args);
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1509..1515

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            var group = function(behavior) {
    return function(obj, iterator, context) {
      var result = {};
      iterator = lookupIterator(iterator);
      each(obj, function(value, index) {
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1594..1604

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 88.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            _.last = function(array, n, guard) {
    if (array == null) return void 0;
    if ((n == null) || guard) return array[array.length - 1];
    return slice.call(array, Math.max(array.length - n, 0));
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1643..1647

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 88.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            _.each(['escape', 'unescape'], function(method) {
    _[method] = function(string) {
      if (string == null) return '';
      return ('' + string).replace(entityRegexes[method], function(match) {
        return entityMap[method][match];
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2167..2174

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            var entityRegexes = {
    escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
    unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2163..2166

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 84.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            _.functions = _.methods = function(obj) {
    var names = [];
    for (var key in obj) {
      if (_.isFunction(obj[key])) names.push(key);
    }
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1948..1954

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.times = function(n, iterator, context) {
    var accum = Array(Math.max(0, n));
    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
    return accum;
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2140..2144

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.find = _.detect = function(obj, predicate, context) {
    var result;
    any(obj, function(value, index, list) {
      if (predicate.call(context, value, index, list)) {
        result = value;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1458..1467

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.extend = function(obj) {
    each(slice.call(arguments, 1), function(source) {
      if (source) {
        for (var prop in source) {
          obj[prop] = source[prop];
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1955..1964

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 78.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            _.random = function(min, max) {
    if (max == null) {
      max = min;
      min = 0;
    }
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2145..2151

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.matches = function(attrs) {
    return function(obj) {
      if (obj === attrs) return true; //avoid comparing an object to itself.
      for (var key in attrs) {
        if (attrs[key] !== obj[key])
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2130..2139

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.once = function(func) {
    var ran = false, memo;
    return function() {
      if (ran) return memo;
      ran = true;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1885..1894

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

                                                                                                                                                                                                                                                                                                                                          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 (typeof exports !== 'undefined') {
    if (typeof module !== 'undefined' && module.exports) {
      exports = module.exports = _;
    }
    exports._ = _;
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1380..1387

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            each(['concat', 'join', 'slice'], function(name) {
    var method = ArrayProto[name];
    _.prototype[name] = function() {
      return result.call(this, method.apply(this._wrapped, arguments));
    };
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2276..2281

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.difference = function(array) {
    var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
    return _.filter(array, function(value){ return !_.contains(rest, value); });
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1708..1711

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.partition = function(array, predicate) {
    var pass = [], fail = [];
    each(array, function(elem) {
      (predicate(elem) ? pass : fail).push(elem);
    });
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1673..1679

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 73.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            _.clone = function(obj) {
    if (!_.isObject(obj)) return obj;
    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1991..1994

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.result = function(object, property) {
    if (object == null) return void 0;
    var value = object[property];
    return _.isFunction(value) ? value.call(object) : value;
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2175..2179

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.size = function(obj) {
    if (obj == null) return 0;
    return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1630..1633

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
    _['is' + name] = function(obj) {
      return toString.call(obj) == '[object ' + name + ']';
    };
  });
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2078..2082

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 65.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            _.groupBy = group(function(result, key, value) {
    _.has(result, key) ? result[key].push(value) : result[key] = [value];
  });
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1605..1607

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 63.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            _.rest = _.tail = _.drop = function(array, n, guard) {
    return slice.call(array, (n == null) || guard ? 1 : n);
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1648..1650

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.delay = function(func, wait) {
    var args = slice.call(arguments, 2);
    return setTimeout(function(){ return func.apply(null, args); }, wait);
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1817..1820

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 59.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            _.extend(_.prototype, {
    chain: function() {
      this._chain = true;
      return this;
    },
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2283..2292

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

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.reject = function(obj, predicate, context) {
    return _.filter(obj, function(value, index, list) {
      return !predicate.call(context, value, index, list);
    }, context);
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1477..1481

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 56.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            var lookupIterator = function(value) {
    if (value == null) return _.identity;
    if (_.isFunction(value)) return value;
    return _.property(value);
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1571..1575

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 54.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            _.countBy = group(function(result, key) {
    _.has(result, key) ? result[key]++ : result[key] = 1;
  });
                                                                                                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1611..1613

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 54.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            _.initial = function(array, n, guard) {
    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1640..1642

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 54.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            if (!_.isArguments(arguments)) {
    _.isArguments = function(obj) {
      return !!(obj && _.has(obj, 'callee'));
    };
  }
                                                                                                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2083..2087

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 54.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            _.defer = function(func) {
    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1821..1823

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 53.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            var _ = function(obj) {
    if (obj instanceof _) return obj;
    if (!(this instanceof _)) return new _(obj);
    this._wrapped = obj;
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1375..1379

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.after = function(times, func) {
    return function() {
      if (--times < 1) {
        return func.apply(this, arguments);
      }
                                                                                                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1908..1914

                                                                                                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                                                                                            _.isBoolean = function(obj) {
    return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
  };
                                                                                                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 2099..2101

                                                                                                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                                                                                                          This issue has a mass of 48.

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

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

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

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

                                                                                                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                                                                            var
    push             = ArrayProto.push,
    slice            = ArrayProto.slice,
    concat           = ArrayProto.concat,
    toString         = ObjProto.toString,
                                                                                                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                                                                                                          Found in samples/adminpanel/app/bower_components/ace-builds/src/worker-javascript.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                                                                                                          samples/adminpanel/app/bower_components/ace-builds/src-noconflict/worker-javascript.js on lines 1356..1361

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

                                                                                                                                                                                                                                                                                                                                          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