kuasha/cosmos

View on GitHub
samples/adminpanel/app/bower_components/ace-builds/demo/kitchen-sink/demo.js

Summary

Maintainability
F
1 yr
Test Coverage

File demo.js has 6401 lines of code (exceeds 250 allowed). Consider refactoring.
Open

define("ace/ext/spellcheck",["require","exports","module","ace/lib/event","ace/editor","ace/config"], function(require, exports, module) {
"use strict";
var event = require("../lib/event");

exports.contextMenuHandler = function(e){

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

    var AcePopup = function(parentNode) {
        var el = dom.createElement("div");
        var popup = new $singleLineEditor(el);
    
        if (parentNode)

      Function transform has 150 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      exports.transform = function(iterator, maxPos, context) {
          var token = iterator.getCurrentToken();
          
          var newLines = exports.newLines;
          var spaces = exports.spaces;

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

            this.insertSnippetForSelection = function(editor, snippetText) {
                var cursor = editor.getCursorPosition();
                var line = editor.session.getLine(cursor.row);
                var tabString = editor.session.getTabString();
                var indentString = line.match(/^\s*/)[0];

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

              this.getTokenizer = function() {
                  function TabstopToken(str, _, stack) {
                      str = str.substr(1);
                      if (/^\d+$/.test(str) && !stack.inFormatString)
                          return [{tabstopId: parseInt(str, 10)}];

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

                push: function(editor, ch, keyId) {
                    var status = this.status;
                    var isKeyHandled = true;
                    this.idle = false;
                    var wObj = this.waitingForParam;

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

              exports.createSplitEditor = function(el) {
                  if (typeof(el) == "string")
                      el = document.getElementById(el);
              
                  var e0 = document.createElement("div");

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

                    this.register = function(snippets, scope) {
                        var snippetMap = this.snippetMap;
                        var snippetNameMap = this.snippetNameMap;
                        var self = this;
                        function wrapRegexp(src) {

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

                      exec: function(editor, action, param) {
                          var m = action.motion;
                          var o = action.operator;
                          var a = action.action;
                  
                  

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

                    var StringStream = function(editor, cursor) {
                        var sel = editor.selection;
                        this.range = sel.getRange();
                        cursor = cursor || sel.selectionLead;
                        this.row = cursor.row;

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

                          exec: function(editor) {
                              var split = window.env.split;
                              var s = editor.session;
                              var inlineEditor = new Editor(new Renderer());
                              var splitSession = split.$cloneSession(s);

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

                        exports.$detectIndentation = function(lines, fallback) {
                            var stats = [];
                            var changes = [];
                            var tabIndents = 0;
                            var prevSpaces = 0;

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

                              this.update = function() {
                                  this.$timer = null;
                                  
                                  var r = this.editor.renderer;
                                  if (this.lastT - (r.timeStamp || 0) > 1000) {

                            Function addTabstops has 45 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                this.addTabstops = function(tabstops, start, end) {
                                    if (!this.$openTabstops)
                                        this.$openTabstops = [];
                                    if (!tabstops[0]) {
                                        var p = Range.fromPoints(end, end);

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

                                  this.onChange = function(e) {
                                      var changeRange = e.data.range;
                                      var isRemove = e.data.action[0] == "r";
                                      var start = changeRange.start;
                                      var end = changeRange.end;

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

                                    handleKeyboard: function(data, hashId, key, keyCode, e) {
                                        if (hashId !== 0 && (!key || keyCode == -1))
                                            return null;
                                        
                                        var editor = data.editor;

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

                                  exports.contextMenuHandler = function(e){
                                      var host = e.target;
                                      var text = host.textInput.getElement();
                                      if (!host.selection.isEmpty())
                                          return;

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

                                        this.resolveVariables = function(snippet, editor) {
                                            var result = [];
                                            for (var i = 0; i < snippet.length; i++) {
                                                var ch = snippet[i];
                                                if (typeof ch == "string") {

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

                                          this.updateCompletions = function(keepPopupPosition) {
                                              if (keepPopupPosition && this.base && this.completions) {
                                                  var pos = this.editor.getCursorPosition();
                                                  var prefix = this.editor.session.getTextRange({start: this.base, end: pos});
                                                  if (prefix == this.completions.filterText)

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

                                            $updateTabstops: function(value) {
                                                var base = 1000;
                                                var zeroBase = 0;
                                                var lastZero = null;
                                                var range = emmet.require('range');

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

                                                  sel: function(editor, range, count, param) {
                                                      switch (param) {
                                                          case "w":
                                                              editor.selection.selectAWord();
                                                              break;

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

                                                this.tmStrFormat = function(str, ch, editor) {
                                                    var flag = ch.flag || "";
                                                    var re = ch.guard;
                                                    re = new RegExp(re, flag.replace(/[^gi]/, ""));
                                                    var fmtTokens = this.tokenizeTmSnippet(ch.fmt, "formatString");

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

                                                  this.$getDefaultValue = function(editor, name) {
                                                      if (/^[A-Z]\d+$/.test(name)) {
                                                          var i = name.substr(1);
                                                          return (this.variables[name[0] + "__"] || {})[i];
                                                      }

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

                                                        sel: function(editor, range, count, param) {
                                                            switch (param) {
                                                                case "w":
                                                                    editor.selection.selectWord();
                                                                    break;

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

                                                  var handleCursorMove = exports.onCursorMove = function(editor, e) {
                                                      if (util.currentMode === 'insert' || handleCursorMove.running)
                                                          return;
                                                      else if(!editor.selection.isEmpty()) {
                                                          handleCursorMove.running = true;

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

                                                        this.parseSnippetFile = function(str) {
                                                            str = str.replace(/\r/g, "");
                                                            var list = [], snippet = {};
                                                            var re = /^#.*|^({[\s\S]*})\s*$|^(\S+) (.*)$|^((?:\n*\t.*)+)/gm;
                                                            var m;

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

                                                              fn: function(editor, range, count, param) {
                                                                  count = count || 1;
                                                                  switch (param) {
                                                                      case "d":
                                                                          registers._default.text = "";

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

                                                            this.filterCompletions = function(items, needle) {
                                                                var results = [];
                                                                var upper = needle.toUpperCase();
                                                                var lower = needle.toLowerCase();
                                                                loop: for (var i = 0, item; item = items[i]; i++) {

                                                          Function updateMacCompositionHandlers has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                                                          Open

                                                              updateMacCompositionHandlers: function(editor, enable) {
                                                                  var onCompositionUpdateOverride = function(text) {
                                                                      if (util.currentMode !== "insert") {
                                                                          var el = this.textInput.getElement();
                                                                          el.blur();

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

                                                            env.editSnippets = function() {
                                                                var sp = env.split;
                                                                if (sp.getSplits() == 2) {
                                                                    sp.setSplits(1);
                                                                    return;

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

                                                                  this.$setBlockCellWidthsToMax = function(cellWidths) {
                                                                      var startingNewBlock = true, blockStartRow, blockEndRow, maxWidth;
                                                                      var columnInfo = this.$izip_longest(cellWidths);
                                                              
                                                                      for (var c = 0, l = columnInfo.length; c < l; c++) {

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

                                                                    bgTokenizer.$tokenizeRow = function(i) {
                                                                        var data = popup.data[i];
                                                                        var tokens = [];
                                                                        if (!data)
                                                                            return tokens;

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

                                                                          var formatted = str.replace(re, function() {
                                                                              _self.variables.__ = arguments;
                                                                              var fmtParts = _self.resolveVariables(fmtTokens, editor);
                                                                              var gChangeCase = "E";
                                                                              for (var i  = 0; i < fmtParts.length; i++) {

                                                                    Consider simplifying this complex logical expression.
                                                                    Open

                                                                                    if (
                                                                                        lastToken.type == newLines[i].type &&
                                                                                        (
                                                                                            !newLines[i].value || lastToken.value == newLines[i].value
                                                                                        ) &&

                                                                      Consider simplifying this complex logical expression.
                                                                      Open

                                                                                  if (
                                                                                      token.type == newLines[i].type &&
                                                                                      (
                                                                                          !newLines[i].value ||
                                                                                          token.value == newLines[i].value

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

                                                                                getPos: function(editor, range, count, param, isSel, isRepeat) {

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

                                                                                  getPos: function(editor, range, count, param, isSel, isRepeat) {

                                                                            Avoid deeply nested control flow statements.
                                                                            Open

                                                                                                if (!newLines[i].dontBreak  && !breakAdded) {
                                                                                                    code += "\n";
                                                                                                    for (i = 0; i < indentation; i++) {
                                                                                                        code += "\t";
                                                                                                    }

                                                                              Avoid deeply nested control flow statements.
                                                                              Open

                                                                                                          if (ch.changeCase == "u")
                                                                                                              fmtParts[i] = next[0].toUpperCase();
                                                                                                          else
                                                                                                              fmtParts[i] = next[0].toLowerCase();

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

                                                                                        getPos: function(editor, range, count, param, isSel, isRepeat) {

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

                                                                                          getPos: function(editor, range, count, param, isSel, isRepeat) {

                                                                                    Avoid deeply nested control flow statements.
                                                                                    Open

                                                                                                        if (newLines[i].indent === true) {
                                                                                                            indentation++;
                                                                                                        }

                                                                                      Avoid deeply nested control flow statements.
                                                                                      Open

                                                                                                          for (i = 0; i < indentation; i++) {
                                                                                                              code += "\t";
                                                                                                          }

                                                                                        Consider simplifying this complex logical expression.
                                                                                        Open

                                                                                                    if (
                                                                                                        token.type == spaces[i].type &&
                                                                                                        (!spaces[i].value || token.value == spaces[i].value) &&
                                                                                                        (
                                                                                                            nextToken &&

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

                                                                                              handleKeyboard: function(data, hashId, key, keyCode, e) {

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

                                                                                                    getPos: function(editor, range, count, param, isSel) {

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

                                                                                                      getPos: function(editor, range, count, param, isSel) {

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

                                                                                                    getCompletions: function(editor, session, pos, prefix, callback) {

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

                                                                                                          getPos: function(editor, range, count, param, isSel) {

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

                                                                                                            getPos: function(editor, range, count, param, isSel) {

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

                                                                                                          exports.getCompletions = function(editor, session, pos, prefix, callback) {

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

                                                                                                            getCompletions: function(editor, session, pos, prefix, callback) {

                                                                                                          Avoid too many return statements within this function.
                                                                                                          Open

                                                                                                                          return {command: "null", passEvent: true};

                                                                                                            Avoid too many return statements within this function.
                                                                                                            Open

                                                                                                                    return newVal;

                                                                                                              Avoid too many return statements within this function.
                                                                                                              Open

                                                                                                                              return {command: "removewordleft"};

                                                                                                                Avoid too many return statements within this function.
                                                                                                                Open

                                                                                                                                    return startCommands[key];

                                                                                                                  Avoid too many return statements within this function.
                                                                                                                  Open

                                                                                                                                      return;

                                                                                                                    Avoid too many return statements within this function.
                                                                                                                    Open

                                                                                                                                    return "";

                                                                                                                      Avoid too many return statements within this function.
                                                                                                                      Open

                                                                                                                                  return '\n';

                                                                                                                        Avoid too many return statements within this function.
                                                                                                                        Open

                                                                                                                                        return {command: coreCommands.stop};

                                                                                                                          Avoid too many return statements within this function.
                                                                                                                          Open

                                                                                                                                          return {command: "null", passEvent: !isHandled}; 

                                                                                                                            Avoid too many return statements within this function.
                                                                                                                            Open

                                                                                                                                            return this.insertMatch(filtered[0]);

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

                                                                                                                              define("ace/snippets",["require","exports","module","ace/lib/oop","ace/lib/event_emitter","ace/lib/lang","ace/range","ace/anchor","ace/keyboard/hash_handler","ace/tokenizer","ace/lib/dom","ace/editor"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              var oop = require("./lib/oop");
                                                                                                                              var EventEmitter = require("./lib/event_emitter").EventEmitter;
                                                                                                                              var lang = require("./lib/lang");
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-emmet.js on lines 1..898
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-language_tools.js on lines 1..898
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/mode-jsoniq.js on lines 2715..3612
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/mode-xquery.js on lines 2749..3646

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

                                                                                                                              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/keyboard/vim/maps/motions",["require","exports","module","ace/keyboard/vim/maps/util","ace/search","ace/range"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              
                                                                                                                              var util = require("./util");
                                                                                                                              
                                                                                                                              
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/keybinding-vim.js on lines 142..786

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

                                                                                                                              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/keyboard/vim/commands",["require","exports","module","ace/lib/lang","ace/keyboard/vim/maps/util","ace/keyboard/vim/maps/motions","ace/keyboard/vim/maps/operators","ace/keyboard/vim/maps/aliases","ace/keyboard/vim/registers"], function(require, exports, module) {
                                                                                                                              
                                                                                                                              "never use strict";
                                                                                                                              
                                                                                                                              var lang = require("../../lib/lang");
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/keybinding-vim.js on lines 1022..1596

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

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

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

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

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

                                                                                                                              Refactorings

                                                                                                                              Further Reading

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

                                                                                                                              define("ace/autocomplete",["require","exports","module","ace/keyboard/hash_handler","ace/autocomplete/popup","ace/autocomplete/util","ace/lib/event","ace/lib/lang","ace/snippets"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              
                                                                                                                              var HashHandler = require("./keyboard/hash_handler").HashHandler;
                                                                                                                              var AcePopup = require("./autocomplete/popup").AcePopup;
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-language_tools.js on lines 1249..1595
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/mode-jsoniq.js on lines 3963..4309
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/mode-xquery.js on lines 3997..4343

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

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

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

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

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

                                                                                                                              Refactorings

                                                                                                                              Further Reading

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

                                                                                                                              define("ace/autocomplete/popup",["require","exports","module","ace/edit_session","ace/virtual_renderer","ace/editor","ace/range","ace/lib/event","ace/lib/lang","ace/lib/dom"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              
                                                                                                                              var EditSession = require("../edit_session").EditSession;
                                                                                                                              var Renderer = require("../virtual_renderer").VirtualRenderer;
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-language_tools.js on lines 900..1202
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/mode-jsoniq.js on lines 3614..3916
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/mode-xquery.js on lines 3648..3950

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

                                                                                                                              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/ext/elastic_tabstops_lite",["require","exports","module","ace/editor","ace/config"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              
                                                                                                                              var ElasticTabstopsLite = function(editor) {
                                                                                                                                  this.$editor = editor;
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-elastic_tabstops_lite.js on lines 1..271

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

                                                                                                                              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/ext/emmet",["require","exports","module","ace/keyboard/hash_handler","ace/editor","ace/snippets","ace/range","resources","resources","range","tabStops","resources","utils","actions","ace/config"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              var HashHandler = require("ace/keyboard/hash_handler").HashHandler;
                                                                                                                              var Editor = require("ace/editor").Editor;
                                                                                                                              var snippetManager = require("ace/snippets").snippetManager;
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-emmet.js on lines 900..1163

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

                                                                                                                              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/split",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/lib/event_emitter","ace/editor","ace/virtual_renderer","ace/edit_session"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              
                                                                                                                              var oop = require("./lib/oop");
                                                                                                                              var lang = require("./lib/lang");
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-split.js on lines 1..236

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

                                                                                                                              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/ext/beautify/php_rules",["require","exports","module","ace/token_iterator"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              var TokenIterator = require("ace/token_iterator").TokenIterator;
                                                                                                                              exports.newLines = [{
                                                                                                                                  type: 'support.php_tag',
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-beautify.js on lines 1..304

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

                                                                                                                              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/incremental_search",["require","exports","module","ace/lib/oop","ace/range","ace/search","ace/search_highlight","ace/commands/incremental_search_commands","ace/lib/dom","ace/commands/command_manager","ace/editor","ace/config"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              
                                                                                                                              var oop = require("./lib/oop");
                                                                                                                              var Range = require("./range").Range;
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/keybinding-emacs.js on lines 365..555

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

                                                                                                                              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/ext/whitespace",["require","exports","module","ace/lib/lang"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              
                                                                                                                              var lang = require("../lib/lang");
                                                                                                                              exports.$detectIndentation = function(lines, fallback) {
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-whitespace.js on lines 1..174

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

                                                                                                                              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

                                                                                                                              define("ace/keyboard/vim/maps/operators",["require","exports","module","ace/keyboard/vim/maps/util","ace/keyboard/vim/registers","ace/range"], function(require, exports, module) {
                                                                                                                              
                                                                                                                              "use strict";
                                                                                                                              
                                                                                                                              var util = require("./util");
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/keybinding-vim.js on lines 788..956

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

                                                                                                                              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/commands/incremental_search_commands",["require","exports","module","ace/config","ace/lib/oop","ace/keyboard/hash_handler","ace/commands/occur_commands"], function(require, exports, module) {
                                                                                                                              
                                                                                                                              var config = require("../config");
                                                                                                                              var oop = require("../lib/oop");
                                                                                                                              var HashHandler = require("../keyboard/hash_handler").HashHandler;
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/keybinding-emacs.js on lines 188..363

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

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

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

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

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

                                                                                                                              Refactorings

                                                                                                                              Further Reading

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

                                                                                                                              define("ace/ext/language_tools",["require","exports","module","ace/snippets","ace/autocomplete","ace/config","ace/autocomplete/util","ace/autocomplete/text_completer","ace/editor","ace/config"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              
                                                                                                                              var snippetManager = require("../snippets").snippetManager;
                                                                                                                              var Autocomplete = require("../autocomplete").Autocomplete;
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-language_tools.js on lines 1641..1808
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/mode-jsoniq.js on lines 4355..4522
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/mode-xquery.js on lines 4389..4556

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

                                                                                                                              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/keyboard/vim",["require","exports","module","ace/keyboard/vim/commands","ace/keyboard/vim/maps/util","ace/lib/useragent"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              
                                                                                                                              var cmds = require("./vim/commands");
                                                                                                                              var coreCommands = cmds.coreCommands;
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/keybinding-vim.js on lines 1598..1758

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

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

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

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

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

                                                                                                                              Refactorings

                                                                                                                              Further Reading

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

                                                                                                                              define("ace/ext/modelist",["require","exports","module"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              
                                                                                                                              var modes = [];
                                                                                                                              function getModeForPath(path) {
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-modelist.js on lines 1..173
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-settings_menu.js on lines 57..229

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

                                                                                                                              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/keyboard/vim/maps/util",["require","exports","module","ace/keyboard/vim/registers","ace/lib/dom"], function(require, exports, module) {
                                                                                                                              var registers = require("../registers");
                                                                                                                              
                                                                                                                              var dom = require("../../../lib/dom");
                                                                                                                              dom.importCssString('.insert-mode .ace_cursor{\
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/keybinding-vim.js on lines 14..140

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

                                                                                                                              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/occur",["require","exports","module","ace/lib/oop","ace/range","ace/search","ace/edit_session","ace/search_highlight","ace/lib/dom"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              
                                                                                                                              var oop = require("./lib/oop");
                                                                                                                              var Range = require("./range").Range;
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/keybinding-emacs.js on lines 1..107

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

                                                                                                                              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

                                                                                                                              define("ace/ext/spellcheck",["require","exports","module","ace/lib/event","ace/editor","ace/config"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              var event = require("../lib/event");
                                                                                                                              
                                                                                                                              exports.contextMenuHandler = function(e){
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-spellcheck.js on lines 1..67

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

                                                                                                                              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/commands/occur_commands",["require","exports","module","ace/config","ace/occur","ace/keyboard/hash_handler","ace/lib/oop"], function(require, exports, module) {
                                                                                                                              
                                                                                                                              var config = require("../config"),
                                                                                                                                  Occur = require("../occur").Occur;
                                                                                                                              var occurStartCommand = {
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/keybinding-emacs.js on lines 109..186

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

                                                                                                                              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/ext/statusbar",["require","exports","module","ace/lib/dom","ace/lib/lang"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              var dom = require("ace/lib/dom");
                                                                                                                              var lang = require("ace/lib/lang");
                                                                                                                              
                                                                                                                              
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-statusbar.js on lines 1..48

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

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

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

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

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

                                                                                                                              Refactorings

                                                                                                                              Further Reading

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

                                                                                                                              define("ace/autocomplete/text_completer",["require","exports","module","ace/range"], function(require, exports, module) {
                                                                                                                                  var Range = require("../range").Range;
                                                                                                                                  
                                                                                                                                  var splitRegex = /[^a-zA-Z_0-9\$\-\u00C0-\u1FFF\u2C00-\uD7FF\w]+/;
                                                                                                                              
                                                                                                                              
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-language_tools.js on lines 1597..1639
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/mode-jsoniq.js on lines 4311..4353
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/mode-xquery.js on lines 4345..4387

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

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

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

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

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

                                                                                                                              Refactorings

                                                                                                                              Further Reading

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

                                                                                                                              define("ace/autocomplete/util",["require","exports","module"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              
                                                                                                                              exports.parForEach = function(array, fn, callback) {
                                                                                                                                  var completed = 0;
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-language_tools.js on lines 1204..1247
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/mode-jsoniq.js on lines 3918..3961
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/mode-xquery.js on lines 3952..3995

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

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

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

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

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

                                                                                                                              Refactorings

                                                                                                                              Further Reading

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

                                                                                                                              define("ace/ext/themelist",["require","exports","module","ace/lib/fixoldbrowsers"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              require("ace/lib/fixoldbrowsers");
                                                                                                                              
                                                                                                                              var themeData = [
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-settings_menu.js on lines 231..284
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-themelist.js on lines 1..54

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

                                                                                                                              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

                                                                                                                              define("ace/keyboard/vim/maps/aliases",["require","exports","module"], function(require, exports, module) {
                                                                                                                              module.exports = {
                                                                                                                                  "x": {
                                                                                                                                      operator: {
                                                                                                                                          ch: "d",
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/keybinding-vim.js on lines 960..1020

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

                                                                                                                              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

                                                                                                                              define("ace/ext/beautify",["require","exports","module","ace/token_iterator","ace/ext/beautify/php_rules"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              var TokenIterator = require("ace/token_iterator").TokenIterator;
                                                                                                                              
                                                                                                                              var phpTransform = require("./beautify/php_rules").transform;
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-beautify.js on lines 306..330

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

                                                                                                                              define("ace/theme/textmate",["require","exports","module","ace/lib/dom"], function(require, exports, module) {
                                                                                                                              "use strict";
                                                                                                                              
                                                                                                                              exports.isDark = false;
                                                                                                                              exports.cssClass = "ace-tm";
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/ext-textarea.js on lines 1..130
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/theme-eclipse.js on lines 1..98
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/theme-textmate.js on lines 1..130

                                                                                                                              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

                                                                                                                              define("ace/keyboard/vim/registers",["require","exports","module"], function(require, exports, module) {
                                                                                                                              
                                                                                                                              "never use strict";
                                                                                                                              
                                                                                                                              module.exports = {
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/src/keybinding-vim.js on lines 1..12

                                                                                                                              Duplicated Code

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

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

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

                                                                                                                              Tuning

                                                                                                                              This issue has a mass of 48.

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

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

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

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

                                                                                                                              Refactorings

                                                                                                                              Further Reading

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

                                                                                                                                  if (typeof id == "string")
                                                                                                                                      var el = document.getElementById(id);
                                                                                                                                  else {
                                                                                                                                      var el = id;
                                                                                                                                      id = el.id;
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/demo/kitchen-sink/demo.js on lines 1298..1303

                                                                                                                              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

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

                                                                                                                                  if (typeof id == "string")
                                                                                                                                      var el = document.getElementById(id);
                                                                                                                                  else {
                                                                                                                                      var el = id;
                                                                                                                                      id = el.id;
                                                                                                                              samples/adminpanel/app/bower_components/ace-builds/demo/kitchen-sink/demo.js on lines 1278..1283

                                                                                                                              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