LearnPAd/learnpad

View on GitHub
lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js

Summary

Maintainability
F
2 mos
Test Coverage

File ext-core-debug.js has 4220 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*!
 * Ext JS Library 3.4.0
 * Copyright(c) 2006-2011 Sencha Inc.
 * licensing@sencha.com
 * http://www.sencha.com/license

    Function DomQuery has a Cognitive Complexity of 410 (exceeds 5 allowed). Consider refactoring.
    Open

    Ext.DomQuery = function(){
        var cache = {}, 
            simpleCache = {}, 
            valueCache = {},
            nonSpace = /\S/,

    Cognitive Complexity

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

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

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

    Further reading

    Function EventManager has a Cognitive Complexity of 244 (exceeds 5 allowed). Consider refactoring.
    Open

    Ext.EventManager = function(){
        var docReadyEvent,
            docReadyProcId,
            docReadyState = false,
            DETECT_NATIVE = Ext.isGecko || Ext.isWebKit || Ext.isSafari,

    Cognitive Complexity

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

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

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

    Further reading

    Function DomQuery has 650 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    Ext.DomQuery = function(){
        var cache = {}, 
            simpleCache = {}, 
            valueCache = {},
            nonSpace = /\S/,

      Function DomHelper has a Cognitive Complexity of 145 (exceeds 5 allowed). Consider refactoring.
      Open

      Ext.DomHelper = function(){
          var tempTableEl = null,
              emptyTags = /^(?:br|frame|hr|img|input|link|meta|range|spacer|wbr|area|param|col)$/i,
              tableRe = /^table|tbody|tr|td$/i,
              confRe = /tag|children|cn|html$/i,

      Cognitive Complexity

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

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

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

      Further reading

      Function EventManager has 385 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      Ext.EventManager = function(){
          var docReadyEvent,
              docReadyProcId,
              docReadyState = false,
              DETECT_NATIVE = Ext.isGecko || Ext.isWebKit || Ext.isSafari,

        Function JSON has a Cognitive Complexity of 66 (exceeds 5 allowed). Consider refactoring.
        Open

        Ext.util.JSON = new (function(){
            var useHasOwn = !!{}.hasOwnProperty,
                isNative = function() {
                    var useNative = null;
        
        

        Cognitive Complexity

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

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

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

        Further reading

        Function DomHelper has 221 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        Ext.DomHelper = function(){
            var tempTableEl = null,
                emptyTags = /^(?:br|frame|hr|img|input|link|meta|range|spacer|wbr|area|param|col)$/i,
                tableRe = /^table|tbody|tr|td$/i,
                confRe = /tag|children|cn|html$/i,

          Function EventObject has a Cognitive Complexity of 54 (exceeds 5 allowed). Consider refactoring.
          Open

          Ext.EventObject = function(){
              var E = Ext.lib.Event,
                  clickRe = /(dbl)?click/,
                  // safari keypress events for special keys return bad keycodes
                  safariKeys = {

          Cognitive Complexity

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

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

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

          Further reading

          Function JSON has 125 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          Ext.util.JSON = new (function(){
              var useHasOwn = !!{}.hasOwnProperty,
                  isNative = function() {
                      var useNative = null;
          
          

            Function EventObject has 116 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            Ext.EventObject = function(){
                var E = Ext.lib.Event,
                    clickRe = /(dbl)?click/,
                    // safari keypress events for special keys return bad keycodes
                    safariKeys = {

              Function doFormUpload has 81 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                      doFormUpload : function(o, ps, url){
                          var id = Ext.id(),
                              doc = document,
                              frame = doc.createElement('iframe'),
                              form = Ext.getDom(o.form),

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

                    slideIn : function(anchor, o){ 
                        o = getObject(o);
                        var me = this,
                            dom = me.dom,
                            st = dom.style,

                  Function compile has 65 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                          compile : function(path, type){
                              type = type || "select";
                  
                              // setup fn preamble
                              var fn = ["var f = function(root){\n var mode; ++batch; var n = root || document;\n"],

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

                            setVisible : function(visible, animate){
                                var me = this, isDisplay, isVisibility, isOffsets, isNosize,
                                    dom = me.dom,
                                    visMode = getVisMode(dom);
                    
                    

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

                          slideOut : function(anchor, o){
                              o = getObject(o);
                              var me = this,
                                  dom = me.dom,
                                  st = dom.style,

                        Function frame has 57 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                            frame : function(color, count, o){
                                o = getObject(o);
                                var me = this,
                                    dom = me.dom,
                                    proxy,

                          Function request has 56 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                                  request : function(o){
                                      var me = this;
                                      if(me.fireEvent(BEFOREREQUEST, me, o)){
                                          if (o.el) {
                                              if(!Ext.isEmpty(o.indicatorText)){

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

                                    insertHtml : function(where, el, html){
                                        var hash = {},
                                            hashVal,
                                            range,
                                            rangeEl,

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

                                  function listen(element, ename, opt, fn, scope){
                                      var o = (!opt || typeof opt == "boolean") ? {} : opt,
                                          el = Ext.getDom(element), task;
                              
                                      fn = fn || o.fn;

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

                                El.get = function(el){
                                    var ex,
                                        elm,
                                        id;
                                    if(!el){ return null; }

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

                                      getAttribute: (function(){
                                          var test = document.createElement('table'),
                                              isBrokenOnTable = false,
                                              hasGetAttribute = 'getAttribute' in test,
                                              unknownRe = /undefined|unknown/;

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

                                        function getNodes(ns, mode, tagName){
                                            var result = [], ri = -1, cs;
                                            if(!ns){
                                                return result;
                                            }

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

                                              getStyle : function(){
                                                  return view && view.getComputedStyle ?
                                                      function(prop){
                                                          var el = this.dom,
                                                              v,

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

                                            function createHtml(o){
                                                var b = '',
                                                    attr,
                                                    val,
                                                    key,

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

                                              ghost : function(anchor, o){
                                                  o = getObject(o);
                                                  var me = this,
                                                      dom = me.dom,
                                                      st = dom.style,

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

                                                var initExtCss = function() {
                                                    // find the body element
                                                    var bd = document.body || document.getElementsByTagName('body')[0];
                                                    if (!bd) {
                                                        return false;

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

                                                  switchOff : function(o){
                                                      o = getObject(o);
                                                      var me = this,
                                                          dom = me.dom,
                                                          st = dom.style,

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

                                                        doEncode = function(o){
                                                            if(!Ext.isDefined(o) || o === null){
                                                                return "null";
                                                            }else if(Ext.isArray(o)){
                                                                return encodeArray(o);

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

                                                      puff : function(o){
                                                          o = getObject(o);
                                                          var me = this,
                                                              dom = me.dom,
                                                              st = dom.style,

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

                                                        function byAttribute(cs, attr, value, op, custom){
                                                            var result = [], 
                                                                ri = -1, 
                                                                useGetStyle = custom == "{",        
                                                                fn = Ext.DomQuery.operators[op],        

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

                                                              removeListener : function(el, eventName, fn, scope){
                                                                  el = Ext.getDom(el);
                                                                  var id = getId(el),
                                                                      f = el && (Ext.elCache[id].events)[eventName] || [],
                                                                      wrap, i, l, k, len, fnc;

                                                        Function argCalc has 11 arguments (exceeds 4 allowed). Consider refactoring.
                                                        Open

                                                                    function argCalc(wrap, style, ww, wh, sXY, sXYval, s1, s2, w, h, p){                    

                                                          Consider simplifying this complex logical expression.
                                                          Open

                                                                      if(me.fireEvent(BEFOREREQUEST, me, o)){
                                                                          if (o.el) {
                                                                              if(!Ext.isEmpty(o.indicatorText)){
                                                                                  me.indicatorText = '<div class="loading-indicator">'+o.indicatorText+"</div>";
                                                                              }

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

                                                                    removeAll : function(el){
                                                                        el = Ext.getDom(el);
                                                                        var id = getId(el),
                                                                            ec = Ext.elCache[id] || {},
                                                                            es = ec.events || {},

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

                                                                   function getId(el){
                                                                      var id = false,
                                                                          i = 0,
                                                                          len = specialElCache.length,
                                                                          skip = false,

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

                                                                    fireEvent : function(){
                                                                        var a = Array.prototype.slice.call(arguments, 0),
                                                                            ename = a[0].toLowerCase(),
                                                                            me = this,
                                                                            ret = TRUE,

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

                                                                              function cb(){
                                                                                  var me = this,
                                                                                      // bogus response object
                                                                                      r = {responseText : '',
                                                                                           responseXML : null,

                                                                    Function getScroll has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
                                                                    Open

                                                                        getScroll : function(){
                                                                            var d = this.dom, 
                                                                                doc = document,
                                                                                body = doc.body,
                                                                                docElement = doc.documentElement,

                                                                    Cognitive Complexity

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

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

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

                                                                    Further reading

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

                                                                        load: function(fileList, callback, scope, preserveOrder) {
                                                                            var scope       = scope || this,
                                                                                head        = document.getElementsByTagName("head")[0],
                                                                                fragment    = document.createDocumentFragment(),
                                                                                numFiles    = fileList.length,

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

                                                                          function nodup(cs){
                                                                              if(!cs){
                                                                                  return [];
                                                                              }
                                                                              var len = cs.length, c, i, r = cs, cj, ri = -1;

                                                                        Function garbageCollect has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                        Open

                                                                        function garbageCollect(){
                                                                            if(!Ext.enableGarbageCollector){
                                                                                clearInterval(El.collectorThreadId);
                                                                            } else {
                                                                                var eid,

                                                                          Function setEvent has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                          Open

                                                                                  setEvent : function(e){
                                                                                      var me = this;
                                                                                      if(e == me || (e && e.browserEvent)){ // already wrapped
                                                                                          return e;
                                                                                      }

                                                                            Function argCalc has 9 arguments (exceeds 4 allowed). Consider refactoring.
                                                                            Open

                                                                                        function argCalc(style, s1, s2, p1, v1, p2, v2, p3, v3){                    

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

                                                                                  shift : function(o){
                                                                                      o = getObject(o);
                                                                                      var dom = this.dom,
                                                                                          a = {};
                                                                                              

                                                                                Function Template has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                                                                                Open

                                                                                Ext.Template = function(html){
                                                                                    var me = this,
                                                                                        a = arguments,
                                                                                        buf = [],
                                                                                        v;

                                                                                Cognitive Complexity

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

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

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

                                                                                Further reading

                                                                                Function load has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                                                                                Open

                                                                                    load: function(fileList, callback, scope, preserveOrder) {
                                                                                        var scope       = scope || this,
                                                                                            head        = document.getElementsByTagName("head")[0],
                                                                                            fragment    = document.createDocumentFragment(),
                                                                                            numFiles    = fileList.length,

                                                                                Cognitive Complexity

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

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

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

                                                                                Further reading

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

                                                                                    function doInsert(el, o, returnElement, pos, sibling, append){

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

                                                                                      fxanim : function(args, opt, animType, defaultDur, defaultEase, cb){

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

                                                                                        function addListener(el, ename, fn, task, wrap, scope){

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

                                                                                              anim : function(args, opt, animType, defaultDur, defaultEase, cb){

                                                                                        Avoid deeply nested control flow statements.
                                                                                        Open

                                                                                                            if(!cc || typeof cc != 'object' || !cc.bubble) {
                                                                                                                c.enableBubble(ename);
                                                                                                            }

                                                                                          Avoid deeply nested control flow statements.
                                                                                          Open

                                                                                                                      switch (typeof v) {
                                                                                                                      case "undefined":
                                                                                                                      case "function":
                                                                                                                      case "unknown":
                                                                                                                          break;

                                                                                            Avoid deeply nested control flow statements.
                                                                                            Open

                                                                                                            if(n && (n.nodeName == utag || n.nodeName == tagName || tagName == '*')){
                                                                                                                result[++ri] = n;
                                                                                                            }

                                                                                              Avoid deeply nested control flow statements.
                                                                                              Open

                                                                                                                          while(k--) {
                                                                                                                              fn[0].tasks[k].cancel();
                                                                                                                          }

                                                                                                Avoid deeply nested control flow statements.
                                                                                                Open

                                                                                                            for(var i = 0, n; n = ns[i]; i++){
                                                                                                                while((n = n.nextSibling)){
                                                                                                                    if (n.nodeName == utag || n.nodeName == tagName || tagName == '*'){
                                                                                                                        result[++ri] = n;
                                                                                                                    }

                                                                                                  Avoid deeply nested control flow statements.
                                                                                                  Open

                                                                                                              if (Ext.isIE && (el.id == undefined || el.id == '')) {
                                                                                                                  el.dom = el.dom;
                                                                                                              } else {
                                                                                                                  el.dom = DOC.getElementById(el.id) || el.dom;
                                                                                                              }

                                                                                                    Avoid deeply nested control flow statements.
                                                                                                    Open

                                                                                                            if(!docEl){
                                                                                                                var f = function(){};
                                                                                                                f.prototype = El.prototype;
                                                                                                                docEl = new f();
                                                                                                                docEl.dom = DOC;

                                                                                                      Avoid deeply nested control flow statements.
                                                                                                      Open

                                                                                                                          if(cj.nodeName == utag || cj.nodeName == tagName  || tagName == '*'){
                                                                                                                              result[++ri] = cj;
                                                                                                                          }

                                                                                                        Avoid deeply nested control flow statements.
                                                                                                        Open

                                                                                                                                for (key in val) {
                                                                                                                                    b += key + ':' + val[key] + ';';
                                                                                                                                };

                                                                                                          Avoid deeply nested control flow statements.
                                                                                                          Open

                                                                                                                          while((n = n.nextSibling) && n.nodeType != 1);

                                                                                                            Consider simplifying this complex logical expression.
                                                                                                            Open

                                                                                                                    if(tag == 'td' && (where == afterbegin || where == beforeend) ||
                                                                                                                       !tableElRe.test(tag) && (where == beforebegin || where == afterend)) {
                                                                                                                        return;
                                                                                                                    }

                                                                                                              Consider simplifying this complex logical expression.
                                                                                                              Open

                                                                                                                      } else if ((tag == 'tbody' && (where == beforeend || where == afterbegin)) ||
                                                                                                                                 (tag == 'tr' && (where == beforebegin || where == afterend))) {
                                                                                                                          node = ieTable(3, tbs, html, tbe);
                                                                                                                      } else {
                                                                                                                          node = ieTable(2, ts, html, te);

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

                                                                                                                        addListener : function(element, eventName, fn, scope, options){

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

                                                                                                                          animate : function(args, duration, onComplete, easing, animType){

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

                                                                                                                        function createSingle(h, el, ename, fn, scope){

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

                                                                                                                          function listen(element, ename, opt, fn, scope){

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

                                                                                                                            function byAttribute(cs, attr, value, op, custom){

                                                                                                                          Avoid too many return statements within this function.
                                                                                                                          Open

                                                                                                                                  return el;

                                                                                                                            Avoid too many return statements within this function.
                                                                                                                            Open

                                                                                                                                    return el;

                                                                                                                              Avoid too many return statements within this function.
                                                                                                                              Open

                                                                                                                                              return isFinite(o) ? String(o) : "null";

                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                Open

                                                                                                                                        return El.select(el);

                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                  Open

                                                                                                                                                  return String(o);

                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                    Open

                                                                                                                                                    return a.join("");

                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                      Open

                                                                                                                                          return null;

                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                        Open

                                                                                                                                                return r;

                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                          Open

                                                                                                                                                  return docEl;

                                                                                                                                            Function each has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                                                                                                                            Open

                                                                                                                                                each : function(fn, scope){
                                                                                                                                                    var me = this,
                                                                                                                                                        els = me.elements,
                                                                                                                                                        len = els.length,
                                                                                                                                                        i, e;

                                                                                                                                            Cognitive Complexity

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

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

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

                                                                                                                                            Further reading

                                                                                                                                            Function buildScriptTag has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                                                                                                                            Open

                                                                                                                                                buildScriptTag: function(filename, callback) {
                                                                                                                                                    var script  = document.createElement('script');
                                                                                                                                                    script.type = "text/javascript";
                                                                                                                                                    script.src  = filename;
                                                                                                                                                    

                                                                                                                                            Cognitive Complexity

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

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

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

                                                                                                                                            Further reading

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

                                                                                                                                                    getHeight : function(contentHeight){
                                                                                                                                                        var me = this,
                                                                                                                                                            dom = me.dom,
                                                                                                                                                            hidden = Ext.isIE && me.isStyle('display', 'none'),
                                                                                                                                                            h = MATH.max(dom.offsetHeight, hidden ? 0 : dom.clientHeight) || 0;
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 3889..3896

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

                                                                                                                                            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

                                                                                                                                                    getWidth : function(contentWidth){
                                                                                                                                                        var me = this,
                                                                                                                                                            dom = me.dom,
                                                                                                                                                            hidden = Ext.isIE && me.isStyle('display', 'none'),
                                                                                                                                                            w = MATH.max(dom.offsetWidth, hidden ? 0 : dom.clientWidth) || 0;
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 3874..3882

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

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                        function after(){
                                                                                                                                                            o.useDisplay ? fly(dom).setDisplayed(FALSE) : fly(dom).hide();  
                                                                                                                                                            fly(dom).clearOpacity();
                                                                                                                                                            fly(dom).setPositioning(r.pos);
                                                                                                                                                            st.width = r.width;
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 5668..5675

                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                            Tuning

                                                                                                                                            This issue has a mass of 122.

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                        function after(){
                                                                                                                                                            o.useDisplay ? fly(dom).setDisplayed(FALSE) : fly(dom).hide();   
                                                                                                                                                            fly(dom).clearOpacity();
                                                                                                                                                            fly(dom).setPositioning(r.pos);
                                                                                                                                                            st.width = r.width;
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 5245..5252

                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                            Tuning

                                                                                                                                            This issue has a mass of 122.

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                     setHeight : function(height, animate){
                                                                                                                                                        var me = this;
                                                                                                                                                        height = me.adjustHeight(height);
                                                                                                                                                        !animate || !me.anim ?
                                                                                                                                                            me.dom.style.height = me.addUnits(height) :
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 3907..3914

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

                                                                                                                                            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

                                                                                                                                                    setWidth : function(width, animate){
                                                                                                                                                        var me = this;
                                                                                                                                                        width = me.adjustWidth(width);
                                                                                                                                                        !animate || !me.anim ?
                                                                                                                                                            me.dom.style.width = me.addUnits(width) :
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 3936..3943

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

                                                                                                                                            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

                                                                                                                                                        "next" : function(c, ss){
                                                                                                                                                            var is = Ext.DomQuery.is,
                                                                                                                                                                r = [], ri = -1;
                                                                                                                                                            for(var i = 0, ci; ci = c[i]; i++){
                                                                                                                                                                var n = next(ci);
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 2120..2130

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

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                        "first-child" : function(c){
                                                                                                                                                            var r = [], ri = -1, n;
                                                                                                                                                            for(var i = 0, ci; ci = n = c[i]; i++){
                                                                                                                                                                while((n = n.previousSibling) && n.nodeType != 1);
                                                                                                                                                                if(!n){
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 1963..1972

                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                            Tuning

                                                                                                                                            This issue has a mass of 113.

                                                                                                                                            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

                                                                                                                                                        "prev" : function(c, ss){
                                                                                                                                                            var is = Ext.DomQuery.is,
                                                                                                                                                                r = [], ri = -1;
                                                                                                                                                            for(var i = 0, ci; ci = c[i]; i++){
                                                                                                                                                                var n = prev(ci);
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 2108..2118

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

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                        "last-child" : function(c){
                                                                                                                                                            var r = [], ri = -1, n;
                                                                                                                                                            for(var i = 0, ci; ci = n = c[i]; i++){
                                                                                                                                                                while((n = n.nextSibling) && n.nodeType != 1);
                                                                                                                                                                if(!n){
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 1952..1961

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

                                                                                                                                            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

                                                                                                                                                    adjustWidth : function(width) {
                                                                                                                                                        var me = this;
                                                                                                                                                        var isNum = (typeof width == "number");
                                                                                                                                                        if(isNum && me.autoBoxAdjust && !me.isBorderBox()){
                                                                                                                                                           width -= (me.getBorderWidth("lr") + me.getPadding("lr"));
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 3593..3600

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

                                                                                                                                            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

                                                                                                                                                    adjustHeight : function(height) {
                                                                                                                                                        var me = this;
                                                                                                                                                        var isNum = (typeof height == "number");
                                                                                                                                                        if(isNum && me.autoBoxAdjust && !me.isBorderBox()){
                                                                                                                                                           height -= (me.getBorderWidth("tb") + me.getPadding("tb"));
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 3583..3590

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

                                                                                                                                            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

                                                                                                                                                    stopEvent : function(){
                                                                                                                                                        var me = this;
                                                                                                                                                        if(me.browserEvent){
                                                                                                                                                            if(me.browserEvent.type == 'mousedown'){
                                                                                                                                                                Ext.EventManager.stoppedMouseDownEvent.fire(me);
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 7785..7793

                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                            Tuning

                                                                                                                                            This issue has a mass of 83.

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                    stopPropagation : function(){
                                                                                                                                                        var me = this;
                                                                                                                                                        if(me.browserEvent){
                                                                                                                                                            if(me.browserEvent.type == 'mousedown'){
                                                                                                                                                                Ext.EventManager.stoppedMouseDownEvent.fire(me);
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 7763..7771

                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                            Tuning

                                                                                                                                            This issue has a mass of 83.

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                getRight : function(local){
                                                                                                                                                    var me = this;
                                                                                                                                                    return !local ? me.getX() + me.getWidth() : (me.getLeft(true) + me.getWidth()) || 0;
                                                                                                                                                },
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 4218..4221

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

                                                                                                                                            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

                                                                                                                                                getBottom : function(local){
                                                                                                                                                    var me = this;
                                                                                                                                                    return !local ? me.getY() + me.getHeight() : (me.getTop(true) + me.getHeight()) || 0;
                                                                                                                                                },
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 4199..4202

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

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                    if (EC[id] && EC[id].el) {
                                                                                                                                                        ex = EC[id].el;
                                                                                                                                                        ex.dom = el;
                                                                                                                                                    } else {
                                                                                                                                                        ex = El.addToCache(new El(el));
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 3026..3031

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

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                    if (EC[el] && EC[el].el) {
                                                                                                                                                        ex = EC[el].el;
                                                                                                                                                        ex.dom = elm;
                                                                                                                                                    } else {
                                                                                                                                                        ex = El.addToCache(new El(elm));
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 3037..3042

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

                                                                                                                                            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

                                                                                                                                                this.encode = function() {
                                                                                                                                                    var ec;
                                                                                                                                                    return function(o) {
                                                                                                                                                        if (!ec) {
                                                                                                                                                            // setup encoding function on first access
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 6946..6955

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

                                                                                                                                            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

                                                                                                                                                this.decode = function() {
                                                                                                                                                    var dc;
                                                                                                                                                    return function(json) {
                                                                                                                                                        if (!dc) {
                                                                                                                                                            // setup decoding function on first access
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 6929..6938

                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                            Tuning

                                                                                                                                            This issue has a mass of 70.

                                                                                                                                            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

                                                                                                                                                    hide : function(animate){
                                                                                                                                                        // hideMode override
                                                                                                                                                        if (typeof animate == 'string'){
                                                                                                                                                            this.setVisible(false, animate);
                                                                                                                                                            return this;
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 4782..4790

                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                            Tuning

                                                                                                                                            This issue has a mass of 67.

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                sequenceFx : function(){
                                                                                                                                                    var me = this;
                                                                                                                                                    me.fxDefaults = Ext.apply(me.fxDefaults || {}, {
                                                                                                                                                        block : FALSE,
                                                                                                                                                        concurrent : FALSE,
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 5702..5710

                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                            Tuning

                                                                                                                                            This issue has a mass of 67.

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                syncFx : function(){
                                                                                                                                                    var me = this;
                                                                                                                                                    me.fxDefaults = Ext.apply(me.fxDefaults || {}, {
                                                                                                                                                        block : FALSE,
                                                                                                                                                        concurrent : TRUE,
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 5717..5725

                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                            Tuning

                                                                                                                                            This issue has a mass of 67.

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                    show : function(animate){
                                                                                                                                                        // hideMode override
                                                                                                                                                        if (typeof animate == 'string'){
                                                                                                                                                            this.setVisible(true, animate);
                                                                                                                                                            return this;
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 4767..4775

                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                            Tuning

                                                                                                                                            This issue has a mass of 67.

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                if(typeof selector == "string"){
                                                                                                                                                    els = Ext.Element.selectorFunction(selector, root);
                                                                                                                                                }else if(selector.length !== undefined){
                                                                                                                                                    els = selector;
                                                                                                                                                }else{
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-foundation-debug.js on lines 3497..3503

                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                            Tuning

                                                                                                                                            This issue has a mass of 63.

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                        b = {x: xy[0], y: xy[1], 0: xy[0], 1: xy[1], width: dom.offsetWidth, height: dom.offsetHeight};
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 4976..4976

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

                                                                                                                                            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

                                                                                                                                                        b = {x: xy[0], y: xy[1], 0: xy[0], 1: xy[1], width: dom.offsetWidth, height: dom.offsetHeight};
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 5089..5089

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

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                        if(lmode && lmode[1]){
                                                                                                                                                            fn[fn.length] = 'mode="'+lmode[1].replace(trimRe, "")+'";';
                                                                                                                                                            path = path.replace(lmode[1], "");
                                                                                                                                                        }
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 1721..1724

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

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                            if(modeMatch[1]){
                                                                                                                                                                fn[fn.length] = 'mode="'+modeMatch[1].replace(trimRe, "")+'";';
                                                                                                                                                                path = path.replace(modeMatch[1], "");
                                                                                                                                                            }
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 1666..1669

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

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                            for(var j = 0, cj; cj = cn[j]; j++){
                                                                                                                                                                if(cj.nodeName == utag || cj.nodeName == tagName  || tagName == '*'){
                                                                                                                                                                    result[++ri] = cj;
                                                                                                                                                                }
                                                                                                                                                            }
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 1439..1443

                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                            Tuning

                                                                                                                                            This issue has a mass of 52.

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                            while((n = n.nextSibling)){
                                                                                                                                                                if (n.nodeName == utag || n.nodeName == tagName || tagName == '*'){
                                                                                                                                                                    result[++ri] = n;
                                                                                                                                                                }
                                                                                                                                                            }
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 1418..1422

                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                            Tuning

                                                                                                                                            This issue has a mass of 52.

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

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

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

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

                                                                                                                                            Refactorings

                                                                                                                                            Further Reading

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

                                                                                                                                                getLeft : function(local){
                                                                                                                                                    return !local ? this.getX() : parseInt(this.getStyle(LEFT), 10) || 0;
                                                                                                                                                },
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 4209..4211

                                                                                                                                            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

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

                                                                                                                                                getTop : function(local) {
                                                                                                                                                    return !local ? this.getY() : parseInt(this.getStyle(TOP), 10) || 0;
                                                                                                                                                },
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 4190..4192

                                                                                                                                            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

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

                                                                                                                                                    for(var i = 0, len = cs.length; i < len; i++){
                                                                                                                                                        cs[i].removeAttribute("_nodup");
                                                                                                                                                    }
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 1606..1608

                                                                                                                                            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

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

                                                                                                                                                    for(var i = 0, len = c1.length; i < len; i++){
                                                                                                                                                       c1[i].removeAttribute("_qdiff");
                                                                                                                                                    }
                                                                                                                                            lp-dashboard-kpi/lp-dash-adoxx-cockpit/src/main/webapp/ext-3.4.0/pkgs/ext-core-debug.js on lines 1556..1558

                                                                                                                                            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