modxcms/revolution

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

Summary

Maintainability
F
2 mos
Test Coverage

File ext-prototype-adapter-debug.js has 1221 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/prototype/ext-prototype-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/prototype/ext-prototype-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 Ajax has 94 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    Ext.lib.Ajax = function(){
        var createSuccess = function(cb){
             return cb.success ? function(xhr){
                cb.success.call(cb.scope||window, createResponse(cb, xhr));
             } : Ext.emptyFn;
    Severity: Major
    Found in manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js - About 3 hrs to fix

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

      Ext.lib.Anim = function(){
      
          var easings = {
              easeOut: function(pos) {
                  return 1-Math.pow(1-pos,2);
      Severity: Major
      Found in manager/assets/ext3/adapter/prototype/ext-prototype-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/prototype/ext-prototype-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/prototype/ext-prototype-adapter-debug.js - About 2 hrs to fix

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

                getXY : function(el){ // this initially used Position.cumulativeOffset but it is not accurate enough
                    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/prototype/ext-prototype-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) {

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

                        run : function(el, args, duration, easing, cb, scope, type){
                            var o = {};
                            for(var k in args){
                                switch(k){   // scriptaculous doesn't support, so convert these
                                    case 'points':

                  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];

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

                        var createResponse = function(cb, xhr){
                            var headerObj = {},
                                headerStr,
                                t,
                                s;

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

                              request : function(method, uri, cb, data, options){
                                  var o = {
                                      method: method,
                                      parameters: data || '',
                                      timeout: cb.timeout,

                        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){

                          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/prototype/ext-prototype-adapter-debug.js - About 50 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/prototype/ext-prototype-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/prototype/ext-prototype-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/prototype/ext-prototype-adapter-debug.js - About 45 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/prototype/ext-prototype-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/prototype/ext-prototype-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/prototype/ext-prototype-adapter-debug.js - About 45 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/prototype/ext-prototype-adapter-debug.js - About 35 mins to fix

                                          Avoid too many return statements within this function.
                                          Open

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

                                            Avoid too many return statements within this function.
                                            Open

                                                                return el;
                                            Severity: Major
                                            Found in manager/assets/ext3/adapter/prototype/ext-prototype-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/jquery/ext-jquery-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/jquery/ext-jquery-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

                                              Ext.lib.Region.prototype = {
                                                  contains : function(region) {
                                                      return ( region.left   >= this.left   &&
                                                               region.right  <= this.right  &&
                                                               region.top    >= this.top    &&
                                              manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 2174..2223

                                              Duplicated Code

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

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

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

                                              Tuning

                                              This issue has a mass of 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/jquery/ext-jquery-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/jquery/ext-jquery-adapter-debug.js on lines 1951..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 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/jquery/ext-jquery-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){
                                                          // not supported so scroll immediately?
                                                          var anim = createAnim(cb, scope);
                                                          el = Ext.getDom(el);
                                                          if(typeof args.scroll.to[0] == 'number'){
                                              manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 2068..2080

                                              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

                                              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/jquery/ext-jquery-adapter-debug.js on lines 2236..2243

                                              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

                                              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/jquery/ext-jquery-adapter-debug.js on lines 2225..2234

                                              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

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

                                              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/jquery/ext-jquery-adapter-debug.js on lines 2101..2106

                                              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/jquery/ext-jquery-adapter-debug.js on lines 2248..2260

                                              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

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

                                                      if((eventName == 'mouseenter' || eventName == 'mouseleave') && !mouseEnterSupported){
                                                          var item = mouseCache[el.id] || (mouseCache[el.id] = {});
                                                          item[eventName] = fn;
                                                          fn = fn.createInterceptor(checkRelatedTarget);
                                                          eventName = (eventName == 'mouseenter') ? 'mouseover' : 'mouseout';
                                              manager/assets/ext3/adapter/yui/ext-yui-adapter-debug.js on lines 1860..1865

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

                                              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((eventName == 'mouseenter' || eventName == 'mouseleave') && !mouseEnterSupported){
                                                          var item = mouseCache[el.id],
                                                              ev = item && item[eventName];
                                              
                                                          if(ev){
                                              manager/assets/ext3/adapter/yui/ext-yui-adapter-debug.js on lines 1870..1879

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

                                              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/jquery/ext-jquery-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/jquery/ext-jquery-adapter-debug.js on lines 2165..2172

                                              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

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

                                                  elContains = function(parent, child) {
                                                     if(parent && parent.firstChild){
                                                       while(child) {
                                                          if(child === parent) {
                                                              return true;
                                              manager/assets/ext3/adapter/yui/ext-yui-adapter-debug.js on lines 1703..1716

                                              Duplicated Code

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

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

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

                                              Tuning

                                              This issue has a mass of 88.

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

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

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

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

                                              Refactorings

                                              Further Reading

                                              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/jquery/ext-jquery-adapter-debug.js on lines 1899..1908

                                              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/jquery/ext-jquery-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

                                                  getDocumentHeight: function() { // missing from prototype?
                                                      var scrollHeight = (document.compatMode != "CSS1Compat") ? document.body.scrollHeight : document.documentElement.scrollHeight;
                                                      return Math.max(scrollHeight, this.getViewportHeight());
                                                  },
                                              manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 1727..1730

                                              Duplicated Code

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

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

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

                                              Tuning

                                              This issue has a mass of 68.

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

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

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

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

                                              Refactorings

                                              Further Reading

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

                                                  getDocumentWidth: function() { // missing from prototype?
                                                      var scrollWidth = (document.compatMode != "CSS1Compat") ? document.body.scrollWidth : document.documentElement.scrollWidth;
                                                      return Math.max(scrollWidth, this.getViewportWidth());
                                                  },
                                              manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 1722..1725

                                              Duplicated Code

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

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

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

                                              Tuning

                                              This issue has a mass of 68.

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

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

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

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

                                              Refactorings

                                              Further Reading

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

                                                  var createFailure = function(cb){
                                                       return cb.failure ? function(xhr){
                                                          cb.failure.call(cb.scope||window, createResponse(cb, xhr));
                                                       } : Ext.emptyFn;
                                                  };
                                              manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 1990..1994

                                              Duplicated Code

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

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

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

                                              Tuning

                                              This issue has a mass of 65.

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

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

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

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

                                              Refactorings

                                              Further Reading

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

                                                  var createSuccess = function(cb){
                                                       return cb.success ? function(xhr){
                                                          cb.success.call(cb.scope||window, createResponse(cb, xhr));
                                                       } : Ext.emptyFn;
                                                  };
                                              manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 1995..1999

                                              Duplicated Code

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

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

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

                                              Tuning

                                              This issue has a mass of 65.

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

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

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

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

                                              Refactorings

                                              Further Reading

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

                                                  preventDefault : function(e){   // missing from prototype?
                                                      e = e.browserEvent || e;
                                                      if(e.preventDefault) {
                                                          e.preventDefault();
                                                      } else {
                                              manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 1960..1967

                                              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

                                                  stopPropagation : function(e){   // missing from prototype?
                                                      e = e.browserEvent || e;
                                                      if(e.stopPropagation) {
                                                          e.stopPropagation();
                                                      } else {
                                              manager/assets/ext3/adapter/prototype/ext-prototype-adapter-debug.js on lines 1951..1958

                                              Duplicated Code

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

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

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

                                              Tuning

                                              This issue has a mass of 64.

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

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

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

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

                                              Refactorings

                                              Further Reading

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

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

                                              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

                                              function fly(el){
                                                  if(!libFlyweight){
                                                      libFlyweight = new Ext.Element.Flyweight();
                                                  }
                                                  libFlyweight.dom = el;
                                              manager/assets/ext3/adapter/jquery/ext-jquery-adapter-debug.js on lines 1834..1840

                                              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