jkuchar/MultipleFileUpload

View on GitHub
public/plupload/js/moxie.js

Summary

Maintainability
F
1 mo
Test Coverage

File moxie.js has 6042 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/**
 * mOxie - multi-runtime File API & XMLHttpRequest L2 Polyfill
 * v1.2.1
 *
 * Copyright 2013, Moxiecode Systems AB
Severity: Major
Found in public/plupload/js/moxie.js - About 2 wks to fix

    Function XMLHttpRequest has 363 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        function XMLHttpRequest() {
            var self = this,
                // this (together with _p() @see below) is here to gracefully upgrade to setter/getter syntax where possible
                props = {
                    /**
    Severity: Major
    Found in public/plupload/js/moxie.js - About 1 day to fix

      Function ExifParser has 311 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          return function ExifParser() {
              // Private ExifParser fields
              var data, tags, Tiff, offsets = {}, tagDescs;
      
              data = new BinaryReader();
      Severity: Major
      Found in public/plupload/js/moxie.js - About 1 day to fix

        Function HTML5Image has 287 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            function HTML5Image() {
                var me = this
                , _img, _imgInfo, _canvas, _binStr, _blob
                , _modified = false // is set true whenever image is modified
                , _preserveHeaders = true
        Severity: Major
        Found in public/plupload/js/moxie.js - About 1 day to fix

          Function Image has 278 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              function Image() {
                  RuntimeClient.call(this);
          
                  Basic.extend(this, {
                      /**
          Severity: Major
          Found in public/plupload/js/moxie.js - About 1 day to fix

            Function XMLHttpRequest has 251 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                function XMLHttpRequest() {
                    var self = this
                    , _xhr
                    , _filename
                    ;
            Severity: Major
            Found in public/plupload/js/moxie.js - About 1 day to fix

              Function UAParser has 249 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  var UAParser = (function (undefined) {
              
                      //////////////
                      // Constants
                      /////////////
              Severity: Major
              Found in public/plupload/js/moxie.js - About 1 day to fix

                Function XMLHttpRequest has 164 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    function XMLHttpRequest() {
                        var _status, _response, _iframe;
                
                        function cleanup(cb) {
                            var target = this, uid, form, inputs, i, hasFile = false;
                Severity: Major
                Found in public/plupload/js/moxie.js - About 6 hrs to fix

                  Function FileInput has 152 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      function FileInput() {
                          var _uid, _files = [], _mimes = [], _options;
                  
                          function addInput() {
                              var comp = this, I = comp.getRuntime(), shimContainer, browseButton, currForm, form, input, uid;
                  Severity: Major
                  Found in public/plupload/js/moxie.js - About 6 hrs to fix

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

                        function Runtime(options, type, caps, modeCaps, preferredMode) {
                            /**
                            Dispatched when runtime is initialized and ready.
                            Results in RuntimeInit on a connected component.
                    
                    
                    Severity: Major
                    Found in public/plupload/js/moxie.js - About 5 hrs to fix

                      Function EventTarget has 137 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                          function EventTarget() {
                              // hash of event listeners by object uid
                              var eventpool = {};
                                      
                              Basic.extend(this, {
                      Severity: Major
                      Found in public/plupload/js/moxie.js - About 5 hrs to fix

                        Function FlashRuntime has 137 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                            function FlashRuntime(options) {
                                var I = this, initTimer;
                        
                                options = Basic.extend({ swf_url: Env.swf_url }, options);
                        
                        
                        Severity: Major
                        Found in public/plupload/js/moxie.js - About 5 hrs to fix

                          Function FileDrop has 135 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                              function FileDrop() {
                                  var _files = [], _allowedExts = [], _options;
                          
                                  Basic.extend(this, {
                                      init: function(options) {
                          Severity: Major
                          Found in public/plupload/js/moxie.js - About 5 hrs to fix

                            Function send has 120 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                        send: function(meta, data) {
                                            var target = this
                                            , isGecko2_5_6 = (Env.browser === 'Mozilla' && Env.version >= 4 && Env.version < 7)
                                            , isAndroidBrowser = Env.browser === 'Android Browser'
                                            , mustSendAsBinary = false
                            Severity: Major
                            Found in public/plupload/js/moxie.js - About 4 hrs to fix

                              Function _doXHR has 109 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                      function _doXHR(data) {
                                          var self = this;
                                          
                                          _start_time = new Date().getTime();
                              
                              
                              Severity: Major
                              Found in public/plupload/js/moxie.js - About 4 hrs to fix

                                Function FileInput has 107 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                    function FileInput(options) {
                                        var self = this,
                                            container, browseButton, defaults;
                                
                                        // if flat argument passed it should be browse_button id
                                Severity: Major
                                Found in public/plupload/js/moxie.js - About 4 hrs to fix

                                  Function FileInput has 99 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                      function FileInput() {
                                          var _files = [], _options;
                                  
                                          Basic.extend(this, {
                                              init: function(options) {
                                  Severity: Major
                                  Found in public/plupload/js/moxie.js - About 3 hrs to fix

                                    Function FileReader has 94 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                        function FileReader() {
                                            var self = this, _fr;
                                                    
                                            Basic.extend(this, {
                                                /**
                                    Severity: Major
                                    Found in public/plupload/js/moxie.js - About 3 hrs to fix

                                      Function SilverlightRuntime has 92 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                          function SilverlightRuntime(options) {
                                              var I = this, initTimer;
                                      
                                              options = Basic.extend({ xap_url: Env.xap_url }, options);
                                      
                                      
                                      Severity: Major
                                      Found in public/plupload/js/moxie.js - About 3 hrs to fix

                                        Function JPEGHeaders has 90 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                            return function JPEGHeaders(data) {
                                                var headers = [], read, idx, marker, length = 0;
                                        
                                                read = new BinaryReader();
                                                read.init(data);
                                        Severity: Major
                                        Found in public/plupload/js/moxie.js - About 3 hrs to fix

                                          Function send has 89 lines of code (exceeds 25 allowed). Consider refactoring.
                                          Open

                                                      send: function(meta, data) {
                                                          var target = this, I = target.getRuntime(), uid, form, input, blob;
                                          
                                                          _status = _response = null;
                                          
                                          
                                          Severity: Major
                                          Found in public/plupload/js/moxie.js - About 3 hrs to fix

                                            Function embed has 87 lines of code (exceeds 25 allowed). Consider refactoring.
                                            Open

                                                        embed: function(el) {
                                                            var self = this
                                                            , imgCopy
                                                            , type, quality, crop
                                                            , options = arguments[1] || {}
                                            Severity: Major
                                            Found in public/plupload/js/moxie.js - About 3 hrs to fix

                                              Function addInput has 86 lines of code (exceeds 25 allowed). Consider refactoring.
                                              Open

                                                      function addInput() {
                                                          var comp = this, I = comp.getRuntime(), shimContainer, browseButton, currForm, form, input, uid;
                                              
                                                          uid = Basic.guid('uid_');
                                              
                                              
                                              Severity: Major
                                              Found in public/plupload/js/moxie.js - About 3 hrs to fix

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

                                                    function Transporter() {
                                                        var mod, _runtime, _data, _size, _pos, _chunk_size;
                                                
                                                        RuntimeClient.call(this);
                                                
                                                
                                                Severity: Major
                                                Found in public/plupload/js/moxie.js - About 3 hrs to fix

                                                  Function JPEG has 74 lines of code (exceeds 25 allowed). Consider refactoring.
                                                  Open

                                                      function JPEG(binstr) {
                                                          var _binstr, _br, _hm, _ep, _info, hasExif;
                                                  
                                                          function _getDimensions() {
                                                              var idx = 0, marker, length;
                                                  Severity: Major
                                                  Found in public/plupload/js/moxie.js - About 2 hrs to fix

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

                                                        function Html5Runtime(options) {
                                                            var I = this
                                                            , Test = Runtime.capTest
                                                            , True = Runtime.capTrue
                                                            ;
                                                    Severity: Major
                                                    Found in public/plupload/js/moxie.js - About 2 hrs to fix

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

                                                              function extractTags(IFD_offset, tags2extract) {
                                                                  var length = data.SHORT(IFD_offset), i, ii,
                                                                      tag, type, count, tagOffset, offset, value, values = [], hash = {};
                                                      
                                                                  for (i = 0; i < length; i++) {
                                                      Severity: Major
                                                      Found in public/plupload/js/moxie.js - About 2 hrs to fix

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

                                                                    function exec(runtime) {
                                                                        _xhr.bind('LoadStart', function(e) {
                                                                            _p('readyState', XMLHttpRequest.LOADING);
                                                                            self.dispatchEvent('readystatechange');
                                                        
                                                        
                                                        Severity: Major
                                                        Found in public/plupload/js/moxie.js - About 2 hrs to fix

                                                          Function init has 71 lines of code (exceeds 25 allowed). Consider refactoring.
                                                          Open

                                                                      init: function(options) {
                                                                          var comp = this, I = comp.getRuntime(), input, shimContainer, mimes, browseButton, zIndex, top;
                                                          
                                                                          _options = options;
                                                                          _files = [];
                                                          Severity: Major
                                                          Found in public/plupload/js/moxie.js - About 2 hrs to fix

                                                            Function version_compare has 68 lines of code (exceeds 25 allowed). Consider refactoring.
                                                            Open

                                                                function version_compare(v1, v2, operator) {
                                                                  // From: http://phpjs.org/functions
                                                                  // +      original by: Philippe Jausions (http://pear.php.net/user/jausions)
                                                                  // +      original by: Aidan Lister (http://aidanlister.com/)
                                                                  // + reimplemented by: Kankrelune (http://www.webfaktory.info/)
                                                            Severity: Major
                                                            Found in public/plupload/js/moxie.js - About 2 hrs to fix

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

                                                                  function Blob(ruid, blob) {
                                                              
                                                                      function _sliceDetached(start, end, type) {
                                                                          var blob, data = blobpool[this.uid];
                                                              
                                                              
                                                              Severity: Major
                                                              Found in public/plupload/js/moxie.js - About 2 hrs to fix

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

                                                                    return function RuntimeClient() {
                                                                        var runtime;
                                                                
                                                                        Basic.extend(this, {
                                                                            /**
                                                                Severity: Major
                                                                Found in public/plupload/js/moxie.js - About 2 hrs to fix

                                                                  Function send has 61 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                  Open

                                                                          send: function(meta, data) {
                                                                              var target = this, self = target.getRuntime();
                                                                  
                                                                              function send() {
                                                                                  meta.transport = self.mode;
                                                                  Severity: Major
                                                                  Found in public/plupload/js/moxie.js - About 2 hrs to fix

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

                                                                        function Html4Runtime(options) {
                                                                            var I = this
                                                                            , Test = Runtime.capTest
                                                                            , True = Runtime.capTrue
                                                                            ;
                                                                    Severity: Major
                                                                    Found in public/plupload/js/moxie.js - About 2 hrs to fix

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

                                                                          function PNG(binstr) {
                                                                              var _binstr, _br, _hm, _ep, _info;
                                                                      
                                                                              _binstr = binstr;
                                                                      
                                                                      
                                                                      Severity: Major
                                                                      Found in public/plupload/js/moxie.js - About 2 hrs to fix

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

                                                                                function _downsize(width, height, crop, preserveHeaders) {
                                                                                    var self = this
                                                                                    , scale
                                                                                    , mathFn
                                                                                    , x = 0
                                                                        Severity: Major
                                                                        Found in public/plupload/js/moxie.js - About 2 hrs to fix

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

                                                                                  function _read(op, blob) {
                                                                                      _fr = new RuntimeTarget();
                                                                          
                                                                                      function error(err) {
                                                                                          self.readyState = FileReader.DONE;
                                                                          Severity: Major
                                                                          Found in public/plupload/js/moxie.js - About 2 hrs to fix

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

                                                                                var can = (function() {
                                                                                    var caps = {
                                                                                            define_property: (function() {
                                                                                                /* // currently too much extra code required, not exactly worth it
                                                                                                try { // as of IE8, getters/setters are supported only on DOM elements
                                                                            Severity: Major
                                                                            Found in public/plupload/js/moxie.js - About 2 hrs to fix

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

                                                                                          dispatchEvent: function(type) {
                                                                                              var uid, list, args, tmpEvt, evt = {}, result = true, undef;
                                                                                              
                                                                                              if (Basic.typeOf(type) !== 'string') {
                                                                                                  // we can't use original object directly (because of Silverlight)
                                                                              Severity: Major
                                                                              Found in public/plupload/js/moxie.js - About 2 hrs to fix

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

                                                                                    function FileDrop(options) {
                                                                                        var self = this, defaults;
                                                                                
                                                                                        // if flat argument passed it should be drop_zone id
                                                                                        if (typeof(options) === 'string') {
                                                                                Severity: Major
                                                                                Found in public/plupload/js/moxie.js - About 2 hrs to fix

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

                                                                                      function FormData() {
                                                                                          var _blob, _fields = [];
                                                                                  
                                                                                          Basic.extend(this, {
                                                                                              /**
                                                                                  Severity: Minor
                                                                                  Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                connectRuntime: function(options) {
                                                                                                    var comp = this, ruid;
                                                                                    
                                                                                                    function initialize(items) {
                                                                                                        var type, constructor;
                                                                                    Severity: Minor
                                                                                    Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                  rgx : function () {
                                                                                      
                                                                                                      // loop through all regexes maps
                                                                                                      for (var result, i = 0, j, k, p, q, matches, match, args = arguments; i < args.length; i += 2) {
                                                                                      
                                                                                      
                                                                                      Severity: Minor
                                                                                      Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                function _rotateToOrientaion(width, height, orientation) {
                                                                                                    switch (orientation) {
                                                                                                        case 5:
                                                                                                        case 6:
                                                                                                        case 7:
                                                                                        Severity: Minor
                                                                                        Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                              var parseUrl = function(url, currentUrl) {
                                                                                                  var key = ['source', 'scheme', 'authority', 'userInfo', 'user', 'pass', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'fragment']
                                                                                                  , i = key.length
                                                                                                  , ports = {
                                                                                                      http: 80,
                                                                                          Severity: Minor
                                                                                          Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                            function onResize() {
                                                                                                                // if possible, embed a canvas element directly
                                                                                                                if (Env.can('create_canvas')) {
                                                                                                                    var canvas = imgCopy.getAsCanvas();
                                                                                                                    if (canvas) {
                                                                                            Severity: Minor
                                                                                            Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                          init: function() {
                                                                                                              self.convertEventPropsToHandlers(dispatches);
                                                                                              
                                                                                                              self.bind('RuntimeInit', function(e, runtime) {
                                                                                                                  self.ruid = runtime.uid;
                                                                                              Severity: Minor
                                                                                              Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                function createIframe() {
                                                                                                                    var container = I.getShimContainer() || document.body
                                                                                                                    , temp = document.createElement('div')
                                                                                                                    ;
                                                                                                
                                                                                                
                                                                                                Severity: Minor
                                                                                                Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                      function isInstalled(version) {
                                                                                                          var isVersionSupported = false, control = null, actualVer,
                                                                                                              actualVerArray, reqVerArray, requiredVersionPart, actualVersionPart, index = 0;
                                                                                                  
                                                                                                          try {
                                                                                                  Severity: Minor
                                                                                                  Found in public/plupload/js/moxie.js - About 1 hr to fix

                                                                                                    Function getPos has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                    Open

                                                                                                        var getPos = function(node, root) {
                                                                                                            var x = 0, y = 0, parent, doc = document, nodeRect, rootRect;
                                                                                                    
                                                                                                            node = node;
                                                                                                            root = root || doc.body;
                                                                                                    Severity: Minor
                                                                                                    Found in public/plupload/js/moxie.js - About 1 hr to fix

                                                                                                      Function FileReader has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                      Open

                                                                                                          function FileReader() {
                                                                                                              var _fr, _convertToBinary = false;
                                                                                                      
                                                                                                              Basic.extend(this, {
                                                                                                      
                                                                                                      
                                                                                                      Severity: Minor
                                                                                                      Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                    setRequestHeader: function(header, value) {
                                                                                                                        var uaHeaders = [ // these headers are controlled by the user agent
                                                                                                                                "accept-charset",
                                                                                                                                "accept-encoding",
                                                                                                                                "access-control-request-headers",
                                                                                                        Severity: Minor
                                                                                                        Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                      send: function(data, options) {                    
                                                                                                                          if (Basic.typeOf(options) === 'string') {
                                                                                                                              _options = { ruid: options };
                                                                                                                          } else if (!options) {
                                                                                                                              _options = {};
                                                                                                          Severity: Minor
                                                                                                          Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                    function cleanup(cb) {
                                                                                                                        var target = this, uid, form, inputs, i, hasFile = false;
                                                                                                            
                                                                                                                        if (!_iframe) {
                                                                                                                            return;
                                                                                                            Severity: Minor
                                                                                                            Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                          getAsBinaryString: function(type, quality) {
                                                                                                                              // if image has not been modified, return the source right away
                                                                                                                              if (!_modified) {
                                                                                                                                  // if image was not loaded from binary string
                                                                                                                                  if (!_binStr) {
                                                                                                              Severity: Minor
                                                                                                              Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                        getInfo: function() {
                                                                                                                            var self = this.getRuntime()
                                                                                                                            , grps = ['tiff', 'exif', 'gps']
                                                                                                                            , info = { meta: {} }
                                                                                                                            , rawInfo = self.shimExec.call(this, 'Image', 'getInfo')
                                                                                                                Severity: Minor
                                                                                                                Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                              init: function(options) {
                                                                                                                                  var comp = this, I = comp.getRuntime(), shimContainer;
                                                                                                                  
                                                                                                                                  // figure out accept string
                                                                                                                                  _options = options;
                                                                                                                  Severity: Minor
                                                                                                                  Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                init: function(options) {
                                                                                                                                    var comp = this, dropZone;
                                                                                                                    
                                                                                                                                    _options = options;
                                                                                                                                    _allowedExts = _extractExts(_options.accept);
                                                                                                                    Severity: Minor
                                                                                                                    Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                              DOMException: (function() {
                                                                                                                                  var namecodes = {
                                                                                                                                      INDEX_SIZE_ERR: 1,
                                                                                                                                      DOMSTRING_SIZE_ERR: 2,
                                                                                                                                      HIERARCHY_REQUEST_ERR: 3,
                                                                                                                      Severity: Minor
                                                                                                                      Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                function _load(src) {
                                                                                                                                    var srcType = Basic.typeOf(src);
                                                                                                                        
                                                                                                                                    try {
                                                                                                                                        // if source is Image
                                                                                                                        Severity: Minor
                                                                                                                        Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                      open: function(method, url, async, user, password) {
                                                                                                                                          var urlp;
                                                                                                                                          
                                                                                                                                          // first two arguments are required
                                                                                                                                          if (!method || !url) {
                                                                                                                          Severity: Minor
                                                                                                                          Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                                _xhr.onreadystatechange = function onReadyStateChange() {
                                                                                                                                                    
                                                                                                                                                    // fake Level 2 events
                                                                                                                                                    switch (_xhr.readyState) {
                                                                                                                                                        
                                                                                                                            Severity: Minor
                                                                                                                            Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                          init: function() {
                                                                                                                                              var html, el, container;
                                                                                                                              
                                                                                                                                              container = this.getShimContainer();
                                                                                                                              
                                                                                                                              
                                                                                                                              Severity: Minor
                                                                                                                              Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                    var removeEvent = function(obj, name, callback) {
                                                                                                                                        var type, undef;
                                                                                                                                        
                                                                                                                                        name = name.toLowerCase();
                                                                                                                                        
                                                                                                                                Severity: Minor
                                                                                                                                Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                      var addEvent = function(obj, name, callback, key) {
                                                                                                                                          var func, events;
                                                                                                                                                      
                                                                                                                                          name = name.toLowerCase();
                                                                                                                                  
                                                                                                                                  
                                                                                                                                  Severity: Minor
                                                                                                                                  Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                        var atob = function(data, utf8) {
                                                                                                                                            if (typeof(window.atob) === 'function') {
                                                                                                                                                return utf8 ? utf8_decode(window.atob(data)) : window.atob(data);
                                                                                                                                            }
                                                                                                                                    
                                                                                                                                    
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                          function renderImageToCanvas(img, canvas, options) {
                                                                                                                                              var iw = img.naturalWidth, ih = img.naturalHeight;
                                                                                                                                              var width = options.width, height = options.height;
                                                                                                                                              var x = options.x || 0, y = options.y || 0;
                                                                                                                                              var ctx = canvas.getContext('2d');
                                                                                                                                      Severity: Minor
                                                                                                                                      Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                                    getResponse: function(responseType) {
                                                                                                                                                        var I = this.getRuntime();
                                                                                                                                        
                                                                                                                                                        try {
                                                                                                                                                            switch (responseType) {
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                                          function initialize(items) {
                                                                                                                                                              var type, constructor;
                                                                                                                                          
                                                                                                                                                              // if we ran out of runtimes
                                                                                                                                                              if (!items.length) {
                                                                                                                                          Severity: Minor
                                                                                                                                          Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                                var btoa = function(data, utf8) {
                                                                                                                                                    if (utf8) {
                                                                                                                                                        utf8_encode(data);
                                                                                                                                                    }
                                                                                                                                            
                                                                                                                                            
                                                                                                                                            Severity: Minor
                                                                                                                                            Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                                          input.onchange = function() { // there should be only one handler for this
                                                                                                                                                              var file;
                                                                                                                                              
                                                                                                                                                              if (!this.value) {
                                                                                                                                                                  return;
                                                                                                                                              Severity: Minor
                                                                                                                                              Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                                            downsize: function(opts) {
                                                                                                                                                                var defaults = {
                                                                                                                                                                    width: this.width,
                                                                                                                                                                    height: this.height,
                                                                                                                                                                    crop: false,
                                                                                                                                                Severity: Minor
                                                                                                                                                Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                                          var UAParser = function (uastring) {
                                                                                                                                                  
                                                                                                                                                              var ua = uastring || ((window && window.navigator && window.navigator.userAgent) ? window.navigator.userAgent : EMPTY);
                                                                                                                                                  
                                                                                                                                                              this.getBrowser = function () {
                                                                                                                                                  Severity: Minor
                                                                                                                                                  Found in public/plupload/js/moxie.js - About 1 hr to fix

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

                                                                                                                                                            function _drawToCanvas(img, canvas, x, y, w, h) {
                                                                                                                                                    Severity: Minor
                                                                                                                                                    Found in public/plupload/js/moxie.js - About 45 mins to fix

                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                      Open

                                                                                                                                                                              if (callback(obj[key], key) === false) {
                                                                                                                                                                                  return;
                                                                                                                                                                              }
                                                                                                                                                      Severity: Major
                                                                                                                                                      Found in public/plupload/js/moxie.js - About 45 mins to fix

                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                        Open

                                                                                                                                                                                        if (/^(\d|[1-9]\d+)$/.test(value)) { // integer (make sure doesn't start with zero)
                                                                                                                                                                                            value = parseInt(value, 10);
                                                                                                                                                                                        } else if (/^\d*\.\d+$/.test(value)) { // double
                                                                                                                                                                                            value = parseFloat(value);
                                                                                                                                                                                        }
                                                                                                                                                        Severity: Major
                                                                                                                                                        Found in public/plupload/js/moxie.js - About 45 mins to fix

                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                          Open

                                                                                                                                                                                          if (typeof(q) === OBJ_TYPE && q.length > 0) {
                                                                                                                                                                                              if (q.length == 2) {
                                                                                                                                                                                                  if (typeof(q[1]) == FUNC_TYPE) {
                                                                                                                                                                                                      // assign modified match
                                                                                                                                                                                                      result[q[0]] = q[1].call(this, match);
                                                                                                                                                          Severity: Major
                                                                                                                                                          Found in public/plupload/js/moxie.js - About 45 mins to fix

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

                                                                                                                                                                function Runtime(options, type, caps, modeCaps, preferredMode) {
                                                                                                                                                            Severity: Minor
                                                                                                                                                            Found in public/plupload/js/moxie.js - About 35 mins to fix

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

                                                                                                                                                                          open: function(method, url, async, user, password) {
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in public/plupload/js/moxie.js - About 35 mins to fix

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

                                                                                                                                                                                    case 5: // RATIONAL
                                                                                                                                                                                        offset = data.LONG(offset) + offsets.tiffHeader;
                                                                                                                                                                
                                                                                                                                                                                        for (ii = 0; ii < count; ii++) {
                                                                                                                                                                                            values[ii] = data.LONG(offset + ii*4) / data.LONG(offset + ii*4 + 4);
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 7749..7756

                                                                                                                                                                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

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

                                                                                                                                                                                    case 10: // SRATIONAL
                                                                                                                                                                                        offset = data.LONG(offset) + offsets.tiffHeader;
                                                                                                                                                                
                                                                                                                                                                                        for (ii = 0; ii < count; ii++) {
                                                                                                                                                                                            values[ii] = data.SLONG(offset + ii*4) / data.SLONG(offset + ii*4 + 4);
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 7731..7738

                                                                                                                                                                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

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

                                                                                                                                                                                    case 4: // LONG
                                                                                                                                                                                        if (count > 1) {
                                                                                                                                                                                            offset = data.LONG(offset) + offsets.tiffHeader;
                                                                                                                                                                                        }
                                                                                                                                                                
                                                                                                                                                                
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 7709..7718

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 89.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                                    case 3: // SHORT
                                                                                                                                                                                        if (count > 2) {
                                                                                                                                                                                            offset = data.LONG(offset) + offsets.tiffHeader;
                                                                                                                                                                                        }
                                                                                                                                                                
                                                                                                                                                                
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 7720..7729

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 89.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                        Basic.extend(this, {
                                                                                                                                                                
                                                                                                                                                                            init : function() {
                                                                                                                                                                                this.trigger("Init");
                                                                                                                                                                            },
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 10118..10129

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

                                                                                                                                                                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

                                                                                                                                                                        Basic.extend(this, {
                                                                                                                                                                            init : function() {
                                                                                                                                                                                this.trigger("Init");
                                                                                                                                                                            },
                                                                                                                                                                
                                                                                                                                                                
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 6148..6160

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

                                                                                                                                                                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

                                                                                                                                                                            Events.addEvent(dropZone, 'dragenter', function(e) {
                                                                                                                                                                                e.preventDefault();
                                                                                                                                                                                var flag = Dom.get(self.uid).dragEnter(e);
                                                                                                                                                                                // If handled, then stop propagation of event in DOM
                                                                                                                                                                                if (flag) {
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9857..9864

                                                                                                                                                                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

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

                                                                                                                                                                            Events.addEvent(dropZone, 'drop', function(e) {
                                                                                                                                                                                e.preventDefault();
                                                                                                                                                                                var flag = Dom.get(self.uid).dragDrop(e);
                                                                                                                                                                                // If handled, then stop propagation of event in DOM
                                                                                                                                                                                if (flag) {
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9848..9855

                                                                                                                                                                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

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

                                                                                                                                                                        OperationNotAllowedException: (function() {
                                                                                                                                                                            
                                                                                                                                                                            function OperationNotAllowedException(code) {
                                                                                                                                                                                this.code = code;
                                                                                                                                                                                this.name = 'OperationNotAllowedException';
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 1696..1709

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

                                                                                                                                                                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

                                                                                                                                                                        EventException: (function() {
                                                                                                                                                                            function EventException(code) {
                                                                                                                                                                                this.code = code;
                                                                                                                                                                                this.name = 'EventException';
                                                                                                                                                                            }
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 1599..1613

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 80.

                                                                                                                                                                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

                                                                                                                                                                            destroy: (function(destroy) { // extend default destroy method
                                                                                                                                                                                return function() {
                                                                                                                                                                                    destroy.call(I);
                                                                                                                                                                                    clearTimeout(initTimer); // initialization check might be still onwait
                                                                                                                                                                                    options = initTimer = destroy = I = null;
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9063..9069

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 70.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                            destroy: (function(destroy) { // extend default destroy method
                                                                                                                                                                                return function() {
                                                                                                                                                                                    destroy.call(I);
                                                                                                                                                                                    clearTimeout(initTimer); // initialization check might be still onwait
                                                                                                                                                                                    options = initTimer = destroy = I = null;
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9734..9740

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 70.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                            if (end < 0) {
                                                                                                                                                                                end = Math.max(blob.size + end, 0);
                                                                                                                                                                            } else if (end > 0) {
                                                                                                                                                                                end = Math.min(end, blob.size);
                                                                                                                                                                            }
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9104..9108

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 67.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                            if (start < 0) {
                                                                                                                                                                                start = Math.max(blob.size + start, 0);
                                                                                                                                                                            } else if (start > 0) {
                                                                                                                                                                                start = Math.min(start, blob.size);
                                                                                                                                                                            }
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9110..9114

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 67.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                                filter_by_extension: Test(function() { // if you know how to feature-detect this, please suggest
                                                                                                                                                                                    return (Env.browser === 'Chrome' && Env.version >= 28) || (Env.browser === 'IE' && Env.version >= 10);
                                                                                                                                                                                }()),
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 10078..10080

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

                                                                                                                                                                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

                                                                                                                                                                            filter_by_extension: Test(function() { // if you know how to feature-detect this, please suggest
                                                                                                                                                                                return (Env.browser === 'Chrome' && Env.version >= 28) || (Env.browser === 'IE' && Env.version >= 10);
                                                                                                                                                                            }()),
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 6098..6100

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

                                                                                                                                                                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 mimeData = "" +
                                                                                                                                                                        "application/msword,doc dot," +
                                                                                                                                                                        "application/pdf,pdf," +
                                                                                                                                                                        "application/pgp-signature,pgp," +
                                                                                                                                                                        "application/postscript,ps ai eps," +
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 1 hr to fix
                                                                                                                                                                public/plupload/js/jquery.ui.plupload/jquery.ui.plupload.js on lines 1103..1119

                                                                                                                                                                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

                                                                                                                                                                        while (parent && parent != root && parent.nodeType) {
                                                                                                                                                                            x += parent.offsetLeft || 0;
                                                                                                                                                                            y += parent.offsetTop || 0;
                                                                                                                                                                            parent = parent.offsetParent;
                                                                                                                                                                        }
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 1517..1521

                                                                                                                                                                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

                                                                                                                                                                        while (parent && parent != root && parent.nodeType) {
                                                                                                                                                                            x -= parent.scrollLeft || 0;
                                                                                                                                                                            y -= parent.scrollTop || 0;
                                                                                                                                                                            parent = parent.parentNode;
                                                                                                                                                                        }
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 1510..1514

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

                                                                                                                                                                            function ImageError(code) {
                                                                                                                                                                                this.code = code;
                                                                                                                                                                                this.name = _findKey(namecodes, code);
                                                                                                                                                                                this.message = this.name + ": ImageError " + this.code;
                                                                                                                                                                            }
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 3 other locations - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 1588..1592
                                                                                                                                                                public/plupload/js/moxie.js on lines 1645..1649
                                                                                                                                                                public/plupload/js/moxie.js on lines 1685..1689

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 63.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                            function RuntimeError(code) {
                                                                                                                                                                                this.code = code;
                                                                                                                                                                                this.name = _findKey(namecodes, code);
                                                                                                                                                                                this.message = this.name + ": RuntimeError " + this.code;
                                                                                                                                                                            }
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 3 other locations - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 1621..1625
                                                                                                                                                                public/plupload/js/moxie.js on lines 1645..1649
                                                                                                                                                                public/plupload/js/moxie.js on lines 1685..1689

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 63.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                            function FileException(code) {
                                                                                                                                                                                this.code = code;
                                                                                                                                                                                this.name = _findKey(namecodes, code);
                                                                                                                                                                                this.message = this.name + ": FileException " + this.code;
                                                                                                                                                                            }
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 3 other locations - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 1588..1592
                                                                                                                                                                public/plupload/js/moxie.js on lines 1621..1625
                                                                                                                                                                public/plupload/js/moxie.js on lines 1685..1689

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 63.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                            function DOMException(code) {
                                                                                                                                                                                this.code = code;
                                                                                                                                                                                this.name = _findKey(namecodes, code);
                                                                                                                                                                                this.message = this.name + ": DOMException " + this.code;
                                                                                                                                                                            }
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 3 other locations - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 1588..1592
                                                                                                                                                                public/plupload/js/moxie.js on lines 1621..1625
                                                                                                                                                                public/plupload/js/moxie.js on lines 1645..1649

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 63.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                            shimExec: function(component, action) {
                                                                                                                                                                                var args = [].slice.call(arguments, 2);
                                                                                                                                                                                return I.getShim().exec(this.uid, component, action, args);
                                                                                                                                                                            },
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9708..9711

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 58.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                            shimExec: function(component, action) {
                                                                                                                                                                                var args = [].slice.call(arguments, 2);
                                                                                                                                                                                return I.getShim().exec(this.uid, component, action, args);
                                                                                                                                                                            },
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9012..9015

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 58.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                    function _formatData(data, op) {
                                                                                                                                                                        switch (op) {
                                                                                                                                                                            case 'readAsText':
                                                                                                                                                                                return Encode.atob(data, 'utf8');
                                                                                                                                                                            case 'readAsBinaryString':
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9248..9258

                                                                                                                                                                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 _formatData(data, op) {
                                                                                                                                                                        switch (op) {
                                                                                                                                                                            case 'readAsText':
                                                                                                                                                                                return Encode.atob(data, 'utf8');
                                                                                                                                                                            case 'readAsBinaryString':
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 1 hr to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9185..9195

                                                                                                                                                                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

                                                                                                                                                                                initTimer = setTimeout(function() {
                                                                                                                                                                                    if (I && !I.initialized) { // runtime might be already destroyed by this moment
                                                                                                                                                                                        I.trigger("Error", new x.RuntimeError(x.RuntimeError.NOT_INIT_ERR));
                                                                                                                                                                                    }
                                                                                                                                                                                }, 5000);
                                                                                                                                                                Severity: Minor
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 55 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9727..9731

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 53.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                                initTimer = setTimeout(function() {
                                                                                                                                                                                    if (I && !I.initialized) { // runtime might be already destroyed by this moment
                                                                                                                                                                                        I.trigger("Error", new x.RuntimeError(x.RuntimeError.NOT_INIT_ERR));
                                                                                                                                                                                    }
                                                                                                                                                                                }, Env.OS !== 'Windows'? 10000 : 5000); // give it more time to initialize in non Windows OS (like Mac)
                                                                                                                                                                Severity: Minor
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 55 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9056..9060

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 53.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                define("moxie/runtime/silverlight/file/Blob", [
                                                                                                                                                                    "moxie/runtime/silverlight/Runtime",
                                                                                                                                                                    "moxie/core/utils/Basic",
                                                                                                                                                                    "moxie/runtime/flash/file/Blob"
                                                                                                                                                                ], function(extensions, Basic, Blob) {
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 4 other locations - About 45 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9889..9895
                                                                                                                                                                public/plupload/js/moxie.js on lines 9913..9919
                                                                                                                                                                public/plupload/js/moxie.js on lines 9937..9943
                                                                                                                                                                public/plupload/js/moxie.js on lines 9961..9967

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

                                                                                                                                                                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

                                                                                                                                                                define("moxie/runtime/silverlight/file/FileReaderSync", [
                                                                                                                                                                    "moxie/runtime/silverlight/Runtime",
                                                                                                                                                                    "moxie/core/utils/Basic",
                                                                                                                                                                    "moxie/runtime/flash/file/FileReaderSync"
                                                                                                                                                                ], function(extensions, Basic, FileReaderSync) {
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 4 other locations - About 45 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9766..9772
                                                                                                                                                                public/plupload/js/moxie.js on lines 9889..9895
                                                                                                                                                                public/plupload/js/moxie.js on lines 9937..9943
                                                                                                                                                                public/plupload/js/moxie.js on lines 9961..9967

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

                                                                                                                                                                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

                                                                                                                                                                define("moxie/runtime/silverlight/xhr/XMLHttpRequest", [
                                                                                                                                                                    "moxie/runtime/silverlight/Runtime",
                                                                                                                                                                    "moxie/core/utils/Basic",
                                                                                                                                                                    "moxie/runtime/flash/xhr/XMLHttpRequest"
                                                                                                                                                                ], function(extensions, Basic, XMLHttpRequest) {
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 4 other locations - About 45 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9766..9772
                                                                                                                                                                public/plupload/js/moxie.js on lines 9889..9895
                                                                                                                                                                public/plupload/js/moxie.js on lines 9913..9919
                                                                                                                                                                public/plupload/js/moxie.js on lines 9961..9967

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

                                                                                                                                                                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

                                                                                                                                                                define("moxie/runtime/silverlight/file/FileReader", [
                                                                                                                                                                    "moxie/runtime/silverlight/Runtime",
                                                                                                                                                                    "moxie/core/utils/Basic",
                                                                                                                                                                    "moxie/runtime/flash/file/FileReader"
                                                                                                                                                                ], function(extensions, Basic, FileReader) {
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 4 other locations - About 45 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9766..9772
                                                                                                                                                                public/plupload/js/moxie.js on lines 9913..9919
                                                                                                                                                                public/plupload/js/moxie.js on lines 9937..9943
                                                                                                                                                                public/plupload/js/moxie.js on lines 9961..9967

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

                                                                                                                                                                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

                                                                                                                                                                define("moxie/runtime/silverlight/runtime/Transporter", [
                                                                                                                                                                    "moxie/runtime/silverlight/Runtime",
                                                                                                                                                                    "moxie/core/utils/Basic",
                                                                                                                                                                    "moxie/runtime/flash/runtime/Transporter"
                                                                                                                                                                ], function(extensions, Basic, Transporter) {
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public/plupload/js/moxie.js and 4 other locations - About 45 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9766..9772
                                                                                                                                                                public/plupload/js/moxie.js on lines 9889..9895
                                                                                                                                                                public/plupload/js/moxie.js on lines 9913..9919
                                                                                                                                                                public/plupload/js/moxie.js on lines 9937..9943

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

                                                                                                                                                                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 o1, o2, o3, h1, h2, h3, h4, bits, i = 0,
                                                                                                                                                                            ac = 0,
                                                                                                                                                                            dec = "",
                                                                                                                                                                            tmp_arr = [];
                                                                                                                                                                Severity: Minor
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 35 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 2145..2148

                                                                                                                                                                Duplicated Code

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

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

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

                                                                                                                                                                Tuning

                                                                                                                                                                This issue has a mass of 47.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                        var o1, o2, o3, h1, h2, h3, h4, bits, i = 0,
                                                                                                                                                                            ac = 0,
                                                                                                                                                                            enc = "",
                                                                                                                                                                            tmp_arr = [];
                                                                                                                                                                Severity: Minor
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 35 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 2077..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 47.

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

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

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

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

                                                                                                                                                                Refactorings

                                                                                                                                                                Further Reading

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

                                                                                                                                                                                    return (Env.browser === 'Firefox' && Env.version >= 4) ||
                                                                                                                                                                                        (Env.browser === 'Opera' && Env.version >= 12) ||
                                                                                                                                                                                        (Env.browser === 'IE' && Env.version >= 10) ||
                                                                                                                                                                Severity: Minor
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 35 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 10107..10109

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

                                                                                                                                                                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

                                                                                                                                                                                    Events.addEvent(Dom.get(options.container), 'mouseup', function() {
                                                                                                                                                                                        comp.trigger('mouseup');
                                                                                                                                                                                    }, comp.uid);
                                                                                                                                                                Severity: Minor
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 35 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 6487..6489

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

                                                                                                                                                                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

                                                                                                                                                                                Events.addEvent(Dom.get(_options.container), 'mouseup', function() {
                                                                                                                                                                                    comp.trigger('mouseup');
                                                                                                                                                                                }, comp.uid);
                                                                                                                                                                Severity: Minor
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 35 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 10329..10331

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

                                                                                                                                                                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

                                                                                                                                                                                    Basic.extend(shimContainer.style, {
                                                                                                                                                                                        position: 'absolute',
                                                                                                                                                                                        top: '0px',
                                                                                                                                                                                        left: '0px',
                                                                                                                                                                                        width: '1px',
                                                                                                                                                                Severity: Minor
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 35 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 9023..9030

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

                                                                                                                                                                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

                                                                                                                                                                                Basic.extend(container.style, {
                                                                                                                                                                                    position: 'absolute',
                                                                                                                                                                                    top: '-8px',
                                                                                                                                                                                    left: '-8px',
                                                                                                                                                                                    width: '9px',
                                                                                                                                                                Severity: Minor
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 35 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 2455..2462

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

                                                                                                                                                                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

                                                                                                                                                                                return (Env.browser === 'Firefox' && Env.version >= 4) ||
                                                                                                                                                                                    (Env.browser === 'Opera' && Env.version >= 12) ||
                                                                                                                                                                                    !!~Basic.inArray(Env.browser, ['Chrome', 'Safari']);
                                                                                                                                                                Severity: Minor
                                                                                                                                                                Found in public/plupload/js/moxie.js and 1 other location - About 35 mins to fix
                                                                                                                                                                public/plupload/js/moxie.js on lines 6135..6137

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

                                                                                                                                                                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