modxcms/revolution

View on GitHub
manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js

Summary

Maintainability
F
2 mos
Test Coverage

File ext-jquery-adapter-debug.js has 1190 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*
This file is part of Ext JS 3.4

Copyright (c) 2011-2013 Sencha Inc

Severity: Major
Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 3 days to fix

    Function TaskRunner has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.
    Open

    Ext.util.TaskRunner = function(interval){
        interval = interval || 10;
        var tasks = [], 
            removeQueue = [],
            id = 0,
    Severity: Minor
    Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 4 hrs to fix

    Cognitive Complexity

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

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

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

    Further reading

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

    Ext.lib.Anim = function(){
        var createAnim = function(cb, scope){
            var animated = true;
            return {
                stop : function(skipToLast){
    Severity: Major
    Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 4 hrs to fix

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

      Ext.lib.Ajax = function(){
          var createComplete = function(cb){
               return function(xhr, status){
                  if((status == 'error' || status == 'timeout') && cb.failure){
                      cb.failure.call(cb.scope||window, createResponse(cb, xhr));
      Severity: Major
      Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 3 hrs to fix

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

        Ext.util.TaskRunner = function(interval){
            interval = interval || 10;
            var tasks = [], 
                removeQueue = [],
                id = 0,
        Severity: Major
        Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 2 hrs to fix

          Function run has 63 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

                  run : function(el, args, duration, easing, cb, scope, type){
                      var anim = createAnim(cb, scope), e = Ext.fly(el, '_animrun');
                      var o = {};
                      for(var k in args){
                          switch(k){   // jquery doesn't support, so convert
          Severity: Major
          Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 2 hrs to fix

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

                    define: function (className, body, createdFn) {
                        var override = body.override,
                            cls, extend, name, namespace;
            
                        if (override) {
            Severity: Major
            Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 2 hrs to fix

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

                  getXY : function(el) {
                      var p, pe, b, scroll, bd = (document.body || document.documentElement);
                      el = Ext.getDom(el);
              
                      if(el == bd){
              Severity: Minor
              Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 2 hrs to fix

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

                        override: function (target, overrides) {
                            var proto, statics;
                
                            if (overrides) {
                                if (target.$isClass) {
                Severity: Minor
                Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 1 hr to fix

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

                          request : function(method, uri, cb, data, options){
                              var o = {
                                  type: method,
                                  url: uri,
                                  data: data,
                  Severity: Minor
                  Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 1 hr to fix

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

                            extend : function(){
                                // inline overrides
                                var io = function(o){
                                    for(var m in o){
                                        this[m] = o[m];
                    Severity: Minor
                    Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 1 hr to fix

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

                          var createResponse = function(cb, xhr){
                              var headerObj = {},
                                  headerStr,
                                  t,
                                  s;
                      Severity: Minor
                      Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 1 hr to fix

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

                                runTasks = function(){
                                    var rqLen = removeQueue.length,
                                        now = new Date().getTime();                                
                                
                                    if(rqLen > 0){
                        Severity: Minor
                        Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 1 hr to fix

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

                                  run : function(el, args, duration, easing, cb, scope, type){
                          Severity: Major
                          Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 50 mins to fix

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

                                    color : function(el, args, duration, easing, cb, scope){
                            Severity: Minor
                            Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 45 mins to fix

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

                                      motion : function(el, args, duration, easing, cb, scope){
                              Severity: Minor
                              Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 45 mins to fix

                                Avoid deeply nested control flow statements.
                                Open

                                                        for (name in overrides) {
                                                            if (overrides.hasOwnProperty(name)) {
                                                                value = overrides[name];
                                
                                                                if (typeof value == 'function') {
                                Severity: Major
                                Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 45 mins to fix

                                  Avoid deeply nested control flow statements.
                                  Open

                                                          if (!target.constructor.$isClass) {
                                                              target.constructor.prototype.callParent = Base.prototype.callParent;
                                                              target.constructor.callParent = Base.callParent;
                                                          }
                                  Severity: Major
                                  Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 45 mins to fix

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

                                            scroll : function(el, args, duration, easing, cb, scope){
                                    Severity: Minor
                                    Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 45 mins to fix

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

                                              formRequest : function(form, uri, cb, data, isUpload, sslUri){
                                      Severity: Minor
                                      Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 45 mins to fix

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

                                            on : function(el, eventName, fn, scope, override){
                                        Severity: Minor
                                        Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 35 mins to fix

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

                                                  request : function(method, uri, cb, data, options){
                                          Severity: Minor
                                          Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 35 mins to fix

                                            Avoid too many return statements within this function.
                                            Open

                                                                return el;
                                            Severity: Major
                                            Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 30 mins to fix

                                              Avoid too many return statements within this function.
                                              Open

                                                                  return e;
                                              Severity: Major
                                              Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js - About 30 mins to fix

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

                                                (function(){
                                                    var idSeed = 0,
                                                        toString = Object.prototype.toString,
                                                        ua = navigator.userAgent.toLowerCase(),
                                                        check = function(r){
                                                manager/assets/ext3/adapter/ext/ext-base-debug.js on lines 64..1286
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 64..1286
                                                manager/assets/ext3/adapter/yui/ext-yui-adapter-debug.js on lines 64..1286

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

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

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

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

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

                                                Refactorings

                                                Further Reading

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

                                                Ext.util.TaskRunner = function(interval){
                                                    interval = interval || 10;
                                                    var tasks = [], 
                                                        removeQueue = [],
                                                        id = 0,
                                                manager/assets/ext3/adapter/ext/ext-base-debug.js on lines 1549..1669
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 1549..1669
                                                manager/assets/ext3/adapter/yui/ext-yui-adapter-debug.js on lines 1549..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 736.

                                                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

                                                    getXY : function(el) {
                                                        var p, pe, b, scroll, bd = (document.body || document.documentElement);
                                                        el = Ext.getDom(el);
                                                
                                                        if(el == bd){
                                                Severity: Major
                                                Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js and 1 other location - About 3 days to fix
                                                manager/assets/ext3/adapter/yui/ext-yui-adapter-debug.js on lines 1748..1815

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

                                                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

                                                Ext.lib.Region.prototype = {
                                                    contains : function(region) {
                                                        return ( region.left   >= this.left   &&
                                                                 region.right  <= this.right  &&
                                                                 region.top    >= this.top    &&
                                                Severity: Major
                                                Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js and 1 other location - About 3 days to fix
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 2202..2251

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

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

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

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

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

                                                Refactorings

                                                Further Reading

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

                                                Ext.apply(Function.prototype, {
                                                     /**
                                                     * Creates an interceptor function. The passed function is called before the original one. If it returns false,
                                                     * the original one is not called. The resulting function returns the results of the original function.
                                                     * The passed function is called with the parameters of the original function. Example usage:
                                                manager/assets/ext3/adapter/ext/ext-base-debug.js on lines 1296..1452
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 1296..1452
                                                manager/assets/ext3/adapter/yui/ext-yui-adapter-debug.js on lines 1296..1452

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

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

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

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

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

                                                Refactorings

                                                Further Reading

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

                                                    var createResponse = function(cb, xhr){
                                                        var headerObj = {},
                                                            headerStr,
                                                            t,
                                                            s;
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 2000..2033

                                                Duplicated Code

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

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

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

                                                Tuning

                                                This issue has a mass of 281.

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

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

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

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

                                                Refactorings

                                                Further Reading

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

                                                Ext.applyIf(Array.prototype, {
                                                    /**
                                                     * Checks whether or not the specified object exists in the array.
                                                     * @param {Object} o The object to check for
                                                     * @param {Number} from (Optional) The index at which to begin the search
                                                manager/assets/ext3/adapter/ext/ext-base-debug.js on lines 1484..1515
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 1484..1515
                                                manager/assets/ext3/adapter/yui/ext-yui-adapter-debug.js on lines 1484..1515

                                                Duplicated Code

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

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

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

                                                Tuning

                                                This issue has a mass of 168.

                                                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

                                                        scroll : function(el, args, duration, easing, cb, scope){
                                                            // scroll anim not supported so just scroll immediately
                                                            var anim = createAnim(cb, scope);
                                                            el = Ext.getDom(el);
                                                            if(typeof args.scroll.to[0] == 'number'){
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 2119..2131

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

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

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

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

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

                                                Refactorings

                                                Further Reading

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

                                                    isAncestor : function(p, c){
                                                        var ret = false;
                                                
                                                        p = Ext.getDom(p);
                                                        c = Ext.getDom(c);
                                                manager/assets/ext3/adapter/ext/ext-base-debug.js on lines 1708..1725
                                                setup/assets/js/ext-core-debug.js on lines 534..551

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

                                                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

                                                    setXY : function(el, xy){
                                                        el = Ext.fly(el, '_setXY');
                                                        el.position();
                                                        var pts = el.translatePoints(xy);
                                                        if(xy[0] !== false){
                                                manager/assets/ext3/adapter/yui/ext-yui-adapter-debug.js on lines 1817..1827

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

                                                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

                                                Ext.lib.Point = function(x, y) {
                                                   if (Ext.isArray(x)) {
                                                      y = x[1];
                                                      x = x[0];
                                                   }
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 2264..2271

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

                                                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

                                                    resolveTextNode: Ext.isGecko ? function(node){
                                                        if(!node){
                                                            return;
                                                        }
                                                        var s = HTMLElement.prototype.toString.call(node);
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 1896..1907

                                                Duplicated Code

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

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

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

                                                Tuning

                                                This issue has a mass of 126.

                                                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

                                                Ext.lib.Region.getRegion = function(el) {
                                                    var p = Ext.lib.Dom.getXY(el);
                                                
                                                    var t = p[1];
                                                    var r = p[0] + el.offsetWidth;
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 2253..2262

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

                                                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(by = args.points.by){
                                                                            var xy = e.getXY();
                                                                            pts = e.translatePoints([xy[0]+by[0], xy[1]+by[1]]);
                                                                        }else{
                                                                            pts = e.translatePoints(args.points.to);
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 2148..2153

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

                                                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(Ext.isIE) {
                                                    function fnCleanUp() {
                                                        var p = Function.prototype;
                                                        delete p.createSequence;
                                                        delete p.defer;
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 2277..2289

                                                Duplicated Code

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

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

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

                                                Tuning

                                                This issue has a mass of 101.

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

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

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

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

                                                Refactorings

                                                Further Reading

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

                                                Ext.apply = function(o, c, defaults){
                                                    // no "this" reference for friendly out of scope calls
                                                    if(defaults){
                                                        Ext.apply(o, defaults);
                                                    }
                                                manager/assets/ext3/adapter/ext/ext-base-debug.js on lines 51..62
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 51..62
                                                manager/assets/ext3/adapter/yui/ext-yui-adapter-debug.js on lines 51..62

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

                                                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

                                                Ext.lib.Region = function(t, r, b, l) {
                                                    this.top = t;
                                                    this[1] = t;
                                                    this.right = r;
                                                    this.bottom = b;
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 2193..2200

                                                Duplicated Code

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

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

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

                                                Tuning

                                                This issue has a mass of 90.

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

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

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

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

                                                Refactorings

                                                Further Reading

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

                                                        var f = function(){
                                                            if(start.getElapsed() > 10000){
                                                                clearInterval(iid);
                                                            }
                                                            var el = document.getElementById(id);
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 1975..1984

                                                Duplicated Code

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

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

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

                                                Tuning

                                                This issue has a mass of 82.

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

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

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

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

                                                Refactorings

                                                Further Reading

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

                                                Ext.applyIf(String, {
                                                    /**
                                                     * Allows you to define a tokenized string and pass an arbitrary number of arguments to replace the tokens.  Each
                                                     * token must be unique, and must increment in the format {0}, {1}, etc.  Example usage:
                                                     * <pre><code>
                                                manager/assets/ext3/adapter/ext/ext-base-debug.js on lines 1458..1479
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 1458..1479
                                                manager/assets/ext3/adapter/yui/ext-yui-adapter-debug.js on lines 1458..1479

                                                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

                                                    getViewWidth : function(full){
                                                        // jQuery doesn't report full window size on document query, so max both
                                                        return full ? Math.max(jQuery(document).width(),jQuery(window).width()) : jQuery(window).width();
                                                    },
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 1702..1705

                                                Duplicated Code

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

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

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

                                                Tuning

                                                This issue has a mass of 64.

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

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

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

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

                                                Refactorings

                                                Further Reading

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

                                                    getViewHeight : function(full){
                                                        // jQuery doesn't report full window size on document query, so max both
                                                        return full ? Math.max(jQuery(document).height(),jQuery(window).height()) : jQuery(window).height();
                                                    },
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 1697..1700

                                                Duplicated Code

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

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

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

                                                Tuning

                                                This issue has a mass of 64.

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

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

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

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

                                                Refactorings

                                                Further Reading

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

                                                    stopPropagation : function(e){
                                                        e = e.browserEvent || e;
                                                        if(e.stopPropagation){
                                                            e.stopPropagation();
                                                        }else{
                                                manager/assets/ext3/adapter/ext/ext-base-debug.js on lines 2111..2118
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 1874..1881
                                                setup/assets/js/ext-core-debug.js on lines 975..982
                                                setup/assets/js/ext-core-debug.js on lines 984..991

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

                                                    preventDefault : function(e){
                                                        e = e.browserEvent || e;
                                                        if(e.preventDefault){
                                                            e.preventDefault();
                                                        }else{
                                                manager/assets/ext3/adapter/ext/ext-base-debug.js on lines 2111..2118
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 1883..1890
                                                setup/assets/js/ext-core-debug.js on lines 975..982
                                                setup/assets/js/ext-core-debug.js on lines 984..991

                                                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

                                                        if (!t) {
                                                            if (ev.type == "mouseout") {
                                                                t = ev.toElement;
                                                            } else if (ev.type == "mouseover") {
                                                                t = ev.fromElement;
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 1912..1918

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

                                                                    case 'height':
                                                                        o.height = args.height.to;
                                                                        if (args.height.from)
                                                                            e.setHeight(args.height.from);
                                                                    break;
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 2119..2123
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 2129..2133
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 2134..2138

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

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

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

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

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

                                                Refactorings

                                                Further Reading

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

                                                                    case 'width':
                                                                        o.width = args.width.to;
                                                                        if (args.width.from)
                                                                            e.setWidth(args.width.from);
                                                                    break;
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 2124..2128
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 2129..2133
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 2134..2138

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

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

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

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

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

                                                Refactorings

                                                Further Reading

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

                                                                    case 'opacity':
                                                                        o.opacity = args.opacity.to;
                                                                        if (args.opacity.from)
                                                                            e.setOpacity(args.opacity.from);
                                                                    break;
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 2119..2123
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 2124..2128
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 2134..2138

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

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

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

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

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

                                                Refactorings

                                                Further Reading

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

                                                                    case 'left':
                                                                        o.left = args.left.to;
                                                                        if (args.left.from)
                                                                            e.setLeft(args.left.from);
                                                                    break;
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 2119..2123
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 2124..2128
                                                manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 2129..2133

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

                                                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 fly(el){
                                                    if(!libFlyweight){
                                                        libFlyweight = new Ext.Element.Flyweight();
                                                    }
                                                    libFlyweight.dom = el;
                                                Severity: Minor
                                                Found in manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js and 1 other location - About 50 mins to fix
                                                manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 2185..2191

                                                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

                                                There are no issues that match your filters.

                                                Category
                                                Status