meteor/meteor

View on GitHub
packages/deprecated/jquery-layout/jquery.layout.js

Summary

Maintainability
F
1 mo
Test Coverage

Function layout has 2774 lines of code (exceeds 25 allowed). Consider refactoring.
Open

$.fn.layout = function (opts) {
    var

    // local aliases to global data
    browser    = $.layout.browser
Severity: Major
Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 wk to fix

    File jquery.layout.js has 3926 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    /**
     * @preserve
     * jquery.layout 1.3.0 - Release Candidate 30.79
     * $Date: 2013-01-12 08:00:00 (Sat, 12 Jan 2013) $
     * $Rev: 303007 $
    Severity: Major
    Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 wk to fix

      Function _initContainer has 139 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      ,    _initContainer = function () {
              var
                  N        = $N[0]    
              ,    $H        = $("html")
              ,    tag        = sC.tagName = N.tagName
      Severity: Major
      Found in packages/deprecated/jquery-layout/jquery.layout.js - About 5 hrs to fix

        Function initResizable has 126 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        ,    initResizable = function (panes) {
                var    draggingAvailable = $.layout.plugins.draggable
                ,    side // set in start()
                ;
                panes = panes ? panes.split(",") : _c.borderPanes;
        Severity: Major
        Found in packages/deprecated/jquery-layout/jquery.layout.js - About 5 hrs to fix

          Function addPane has 119 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          ,    addPane = function (pane, force) {
                  if (!force && !isInitialized()) return;
                  var
                      o        = options[pane]
                  ,    s        = state[pane]
          Severity: Major
          Found in packages/deprecated/jquery-layout/jquery.layout.js - About 4 hrs to fix

            Function sizeHandles has 113 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            ,    sizeHandles = function (evt_or_panes) {
                    var panes = evtPane.call(this, evt_or_panes)
                    panes = panes ? panes.split(",") : _c.borderPanes;
            
                    $.each(panes, function (i, pane) {
            Severity: Major
            Found in packages/deprecated/jquery-layout/jquery.layout.js - About 4 hrs to fix

              Function sizePane has 111 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              ,    sizePane = function (evt_or_pane, size, skipCallback, noAnimation, force) {
                      if (!isInitialized()) return;
                      var    pane    = evtPane.call(this, evt_or_pane) // probably NEVER called from event?
                      ,    o        = options[pane]
                      ,    s        = state[pane]
              Severity: Major
              Found in packages/deprecated/jquery-layout/jquery.layout.js - About 4 hrs to fix

                Function sizeMidPanes has 105 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                ,    sizeMidPanes = function (panes, skipCallback, force) {
                        panes = (panes ? panes : "east,west,center").split(",");
                
                        $.each(panes, function (i, pane) {
                            if (!$Ps[pane]) return; // NO PANE - skip
                Severity: Major
                Found in packages/deprecated/jquery-layout/jquery.layout.js - About 4 hrs to fix

                  Function initOptions has 100 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  ,    initOptions = function () {
                          var data, d, pane, key, val, i, c, o;
                  
                          // reprocess user's layout-options to have correct options sub-key structure
                          opts = $.layout.transformData( opts, true ); // panes = default subkey
                  Severity: Major
                  Found in packages/deprecated/jquery-layout/jquery.layout.js - About 4 hrs to fix

                    Function swapPanes has 96 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    ,    swapPanes = function (evt_or_pane1, pane2) {
                            if (!isInitialized()) return;
                            var pane1 = evtPane.call(this, evt_or_pane1);
                            // change state.edge NOW so callbacks can know where pane is headed...
                            state[pane1].edge = pane2;
                    Severity: Major
                    Found in packages/deprecated/jquery-layout/jquery.layout.js - About 3 hrs to fix

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

                      ,    initHandles = function (panes) {
                              panes = panes ? panes.split(",") : _c.borderPanes;
                      
                              // create toggler DIVs for each pane, and set object pointers for them, eg: $R.north = north toggler DIV
                              $.each(panes, function (i, pane) {
                      Severity: Major
                      Found in packages/deprecated/jquery-layout/jquery.layout.js - About 3 hrs to fix

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

                        ,    open = function (evt_or_pane, slide, noAnimation, noAlert) {
                                if (!isInitialized()) return;
                                var    pane = evtPane.call(this, evt_or_pane)
                                ,    $P    = $Ps[pane]
                                ,    $R    = $Rs[pane]
                        Severity: Major
                        Found in packages/deprecated/jquery-layout/jquery.layout.js - About 2 hrs to fix

                          Function removePane has 69 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                          ,    removePane = function (evt_or_pane, remove, skipResize, destroyChild) {
                                  if (!isInitialized()) return;
                                  var    pane = evtPane.call(this, evt_or_pane)
                                  ,    $P    = $Ps[pane]
                                  ,    $C    = $Cs[pane]
                          Severity: Major
                          Found in packages/deprecated/jquery-layout/jquery.layout.js - About 2 hrs to fix

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

                            ,    close = function (evt_or_pane, force, noAnimation, skipCallback) {
                                    var    pane = evtPane.call(this, evt_or_pane);
                                    // if pane has been initialized, but NOT the complete layout, close pane instantly
                                    if (!state.initialized && $Ps[pane]) {
                                        _closePane(pane, true); // INIT pane as closed
                            Severity: Major
                            Found in packages/deprecated/jquery-layout/jquery.layout.js - About 2 hrs to fix

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

                              ,    _runCallbacks = function (evtName, pane, skipBoundEvents) {
                                      var    hasPane    = pane && isStr(pane)
                                      ,    s        = hasPane ? state[pane] : state
                                      ,    o        = hasPane ? options[pane] : options
                                      ,    lName    = options.name
                              Severity: Major
                              Found in packages/deprecated/jquery-layout/jquery.layout.js - About 2 hrs to fix

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

                                ,    makePaneFit = function (pane, isOpening, skipCallback, force) {
                                        var    o    = options[pane]
                                        ,    s    = state[pane]
                                        ,    c    = _c[pane]
                                        ,    $P    = $Ps[pane]
                                Severity: Major
                                Found in packages/deprecated/jquery-layout/jquery.layout.js - About 2 hrs to fix

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

                                  ,    sizeContent = function (evt_or_panes, remeasure) {
                                          if (!isInitialized()) return;
                                  
                                          var panes = evtPane.call(this, evt_or_panes);
                                          panes = panes ? panes.split(",") : _c.allPanes;
                                  Severity: Major
                                  Found in packages/deprecated/jquery-layout/jquery.layout.js - About 2 hrs to fix

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

                                            function sizePane_2 () {
                                                /*    Panes are sometimes not sized precisely in some browsers!?
                                                 *    This code will resize the pane up to 3 times to nudge the pane to the correct size
                                                 */
                                                var    actual    = dimName==='width' ? $P.outerWidth() : $P.outerHeight()
                                    Severity: Major
                                    Found in packages/deprecated/jquery-layout/jquery.layout.js - About 2 hrs to fix

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

                                      ,    loadState: function (inst, data, opts) {
                                              if (!$.isPlainObject( data ) || $.isEmptyObject( data )) return;
                                      
                                              // normalize data & cache in the state object
                                              data = inst.state.stateData = $.layout.transformData( data ); // panes = default subkey
                                      Severity: Major
                                      Found in packages/deprecated/jquery-layout/jquery.layout.js - About 2 hrs to fix

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

                                        ,    setAsOpen = function (pane, skipCallback) {
                                                var 
                                                    $P        = $Ps[pane]
                                                ,    $R        = $Rs[pane]
                                                ,    $T        = $Ts[pane]
                                        Severity: Minor
                                        Found in packages/deprecated/jquery-layout/jquery.layout.js - About 2 hrs to fix

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

                                              function allowOverflow (el) {
                                                  if (!isInitialized()) return;
                                                  if (this && this.tagName) el = this; // BOUND to element
                                                  var $P;
                                                  if (isStr(el))
                                          Severity: Minor
                                          Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                    function move (oPane, pane) {
                                                        if (!oPane) return;
                                                        var
                                                            P        = oPane.P
                                                        ,    C        = oPane.C
                                            Severity: Minor
                                            Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                              ,    readState: function (inst, opts) {
                                                      // backward compatility
                                                      if ($.type(opts) === 'string') opts = { keys: opts };
                                                      if (!opts) opts = {};
                                                      var    sm        = inst.options.stateManagement
                                              Severity: Minor
                                              Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                        function createFxOptions ( pane ) {
                                                            var    o = options[pane]
                                                            ,    d = options.panes;
                                                            // ensure fxSettings key to avoid errors
                                                            if (!o.fxSettings) o.fxSettings = {};
                                                Severity: Minor
                                                Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                  ,    resizeAll = function (evt_or_refresh) {
                                                          var    oldW    = sC.innerWidth
                                                          ,    oldH    = sC.innerHeight
                                                          ;
                                                          // stopPropagation if called by trigger("layoutdestroy") - use evtPane utility 
                                                  Severity: Minor
                                                  Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                    ,    setSizeLimits = function (pane, slide) {
                                                            if (!isInitialized()) return;
                                                            var 
                                                                o                = options[pane]
                                                            ,    s                = state[pane]
                                                    Severity: Minor
                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                      ,    createMasks = function (pane) {
                                                              var
                                                                  $P        = $Ps[pane]
                                                              ,    s        = state[pane]
                                                              ,    o        = options[pane]
                                                      Severity: Minor
                                                      Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                        ,    setAsClosed = function (pane) {
                                                                if (!$Rs[pane]) return; // handles not initialized yet!
                                                                var
                                                                    $P        = $Ps[pane]
                                                                ,    $R        = $Rs[pane]
                                                        Severity: Minor
                                                        Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                          ,    createChildren = function (evt_or_pane, opts) {
                                                                  var    pane = evtPane.call(this, evt_or_pane)
                                                                  ,    $P    = $Ps[pane]
                                                                  ;
                                                                  if (!$P) return;
                                                          Severity: Minor
                                                          Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                            ,    bindStopSlidingEvents = function (pane, enable) {
                                                                    var    o        = options[pane]
                                                                    ,    s        = state[pane]
                                                                    ,    c        = _c[pane]
                                                                    ,    z        = options.zIndexes
                                                            Severity: Minor
                                                            Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                              ,    msg: function (info, popup, debugTitle, debugOpts) {
                                                                      if ($.isPlainObject(info) && window.debugData) {
                                                                          if (typeof popup === "string") {
                                                                              debugOpts    = debugTitle;
                                                                              debugTitle    = popup;
                                                              Severity: Minor
                                                              Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                                    function keyDown (evt) {
                                                                        if (!evt) return true;
                                                                        var code = evt.keyCode;
                                                                        if (code < 33) return true; // ignore special keys: ENTER, TAB, etc
                                                                
                                                                Severity: Minor
                                                                Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                                  ,    _parseSize = function (pane, size, dir) {
                                                                          if (!dir) dir = _c[pane].dir;
                                                                  
                                                                          if (isStr(size) && size.match(/%/))
                                                                              size = (size === '100%') ? -1 : parseInt(size, 10) / 100; // convert % to decimal
                                                                  Severity: Minor
                                                                  Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                                    ,    _create: function (inst) {
                                                                            var _    = $.layout.state
                                                                            ,    o    = inst.options
                                                                            ,    sm    = o.stateManagement
                                                                            ;
                                                                    Severity: Minor
                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                                      ,    getElementDimensions: function ($E, inset) {
                                                                              var
                                                                              //    dimensions hash - start with current data IF passed
                                                                                  d    = { css: {}, inset: {} }
                                                                              ,    x    = d.css            // CSS hash
                                                                      Severity: Minor
                                                                      Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                                        ,    setPanePosition = function (panes) {
                                                                                panes = panes ? panes.split(",") : _c.borderPanes;
                                                                        
                                                                                // create toggler DIVs for each pane, and set object pointers for them, eg: $R.north = north toggler DIV
                                                                                $.each(panes, function (i, pane) {
                                                                        Severity: Minor
                                                                        Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                                          ,    renameOptions: function (opts) {
                                                                                  var map = $.layout.backwardCompatibility.map
                                                                                  ,    oldData, newData, value
                                                                                  ;
                                                                                  for (var itemPath in map) {
                                                                          Severity: Minor
                                                                          Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                                            ,    showMasks = function (pane, args) {
                                                                                    var    c        = _c[pane]
                                                                                    ,    panes    =  ["center"]
                                                                                    ,    z        = options.zIndexes
                                                                                    ,    a        = $.extend({
                                                                            Severity: Minor
                                                                            Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                                                          ,    drag: function (e, ui) {
                                                                                                  if (!helperClassesSet) { // can only add classes after clone has been added to the DOM
                                                                                                      //$(".ui-draggable-dragging")
                                                                                                      ui.helper
                                                                                                          .addClass( helperClass +" "+ helperPaneClass ) // add helper classes
                                                                              Severity: Minor
                                                                              Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                                                ,    initContent = function (pane, resize) {
                                                                                        if (!isInitialized()) return;
                                                                                        var 
                                                                                            o    = options[pane]
                                                                                        ,    sel    = o.contentSelector
                                                                                Severity: Minor
                                                                                Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                                                  ,    write: function (name, val, cookieOpts) {
                                                                                          var    params    = ""
                                                                                          ,    date    = ""
                                                                                          ,    clear    = false
                                                                                          ,    o        = cookieOpts || {}
                                                                                  Severity: Minor
                                                                                  Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                                                    ,    destroy = function (evt_or_destroyChildren, destroyChildren) {
                                                                                            // UNBIND layout events and remove global object
                                                                                            $(window).unbind("."+ sID);        // resize & unload
                                                                                            $(document).unbind("."+ sID);    // keyDown (hotkeys)
                                                                                    
                                                                                    Severity: Minor
                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                                                      ,    refreshChildren = function (pane, newChild) {
                                                                                              var    $P    = $Ps[pane]
                                                                                              ,    pC    = children[pane]
                                                                                              ,    s    = state[pane]
                                                                                              ,    o
                                                                                      Severity: Minor
                                                                                      Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                                                                var resizePanes = function (evt, ui, pane, resizingDone) {
                                                                                                    var    dragPos    = ui.position
                                                                                                    ,    c        = _c[pane]
                                                                                                    ,    o        = options[pane]
                                                                                                    ,    s        = state[pane]
                                                                                        Severity: Minor
                                                                                        Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

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

                                                                                          ,    hide = function (evt_or_pane, noAnimation) {
                                                                                                  if (!isInitialized()) return;
                                                                                                  var    pane = evtPane.call(this, evt_or_pane)
                                                                                                  ,    o    = options[pane]
                                                                                                  ,    s    = state[pane]
                                                                                          Severity: Minor
                                                                                          Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

                                                                                            Consider simplifying this complex logical expression.
                                                                                            Open

                                                                                                        if ( !$P
                                                                                                        ||    (!o.closable && !s.isShowing && !s.isHiding)    // invalid request // (!o.resizable && !o.closable) ???
                                                                                                        ||    (!force && s.isClosed && !s.isShowing)            // already closed
                                                                                                        ) return queueNext();
                                                                                            Severity: Major
                                                                                            Found in packages/deprecated/jquery-layout/jquery.layout.js - About 1 hr to fix

                                                                                              Avoid deeply nested control flow statements.
                                                                                              Open

                                                                                                                      for (k=0; k < 3; k++) {
                                                                                                                          a = attrs[k];
                                                                                                                          CSS[p+s+a] = style[p+s+a];
                                                                                                                      }
                                                                                              Severity: Major
                                                                                              Found in packages/deprecated/jquery-layout/jquery.layout.js - About 45 mins to fix

                                                                                                Consider simplifying this complex logical expression.
                                                                                                Open

                                                                                                        if ($E && $E.length && (force || $E.css("display") === "none")) { // only if not *already hidden*
                                                                                                            var s = $E[0].style
                                                                                                                // save ONLY the 'style' props because that is what we must restore
                                                                                                            ,    CSS = { display: s.display || '', visibility: s.visibility || '' };
                                                                                                            // show element 'invisibly' so can be measured
                                                                                                Severity: Major
                                                                                                Found in packages/deprecated/jquery-layout/jquery.layout.js - About 40 mins to fix

                                                                                                  Consider simplifying this complex logical expression.
                                                                                                  Open

                                                                                                              if ( !$P
                                                                                                              ||    (!o.resizable && !o.closable && !s.isShowing)    // invalid request
                                                                                                              ||    (s.isVisible && !s.isSliding)                    // already open
                                                                                                              ) return queueNext();
                                                                                                  Severity: Major
                                                                                                  Found in packages/deprecated/jquery-layout/jquery.layout.js - About 40 mins to fix

                                                                                                    Consider simplifying this complex logical expression.
                                                                                                    Open

                                                                                                                    if ((SHIFT && m=="SHIFT") || (CTRL && m=="CTRL") || (CTRL && SHIFT)) { // Modifier matches
                                                                                                                        if (k && code === (isNaN(k) || k <= 9 ? k.toUpperCase().charCodeAt(0) : k)) { // Key matches
                                                                                                                            pane = p;
                                                                                                                            return false; // BREAK
                                                                                                                        }
                                                                                                    Severity: Major
                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js - About 40 mins to fix

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

                                                                                                      ,    sizePane = function (evt_or_pane, size, skipCallback, noAnimation, force) {
                                                                                                      Severity: Minor
                                                                                                      Found in packages/deprecated/jquery-layout/jquery.layout.js - About 35 mins to fix

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

                                                                                                        ,    manualSizePane = function (evt_or_pane, size, skipCallback, noAnimation, force) {
                                                                                                        Severity: Minor
                                                                                                        Found in packages/deprecated/jquery-layout/jquery.layout.js - About 35 mins to fix

                                                                                                          Avoid too many return statements within this function.
                                                                                                          Open

                                                                                                                          return true; // DONE - next pane
                                                                                                          Severity: Major
                                                                                                          Found in packages/deprecated/jquery-layout/jquery.layout.js - About 30 mins to fix

                                                                                                            Avoid too many return statements within this function.
                                                                                                            Open

                                                                                                                        return calc(sW, cW);
                                                                                                            Severity: Major
                                                                                                            Found in packages/deprecated/jquery-layout/jquery.layout.js - About 30 mins to fix

                                                                                                              Avoid too many return statements within this function.
                                                                                                              Open

                                                                                                                          return size;
                                                                                                              Severity: Major
                                                                                                              Found in packages/deprecated/jquery-layout/jquery.layout.js - About 30 mins to fix

                                                                                                                Avoid too many return statements within this function.
                                                                                                                Open

                                                                                                                            return 0;
                                                                                                                Severity: Major
                                                                                                                Found in packages/deprecated/jquery-layout/jquery.layout.js - About 30 mins to fix

                                                                                                                  Avoid too many return statements within this function.
                                                                                                                  Open

                                                                                                                          return false; // no match, so cannot - or don't need to - track zoom
                                                                                                                  Severity: Major
                                                                                                                  Found in packages/deprecated/jquery-layout/jquery.layout.js - About 30 mins to fix

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

                                                                                                                    ,    cssWidth: function ($E, outerWidth) {
                                                                                                                            // a 'calculated' outerHeight can be passed so borders and/or padding are removed if needed
                                                                                                                            if (outerWidth <= 0) return 0;
                                                                                                                    
                                                                                                                            var bs    = !$.layout.browser.boxModel ? "border-box" : $.support.boxSizing ? $E.css("boxSizing") : "content-box"
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 7 hrs to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 468..483

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

                                                                                                                    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

                                                                                                                    ,    cssHeight: function ($E, outerHeight) {
                                                                                                                            // a 'calculated' outerHeight can be passed so borders and/or padding are removed if needed
                                                                                                                            if (outerHeight <= 0) return 0;
                                                                                                                    
                                                                                                                            var bs    = !$.layout.browser.boxModel ? "border-box" : $.support.boxSizing ? $E.css("boxSizing") : "content-box"
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 7 hrs to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 443..458

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

                                                                                                                    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 (dir === "horz") { // north/south
                                                                                                                                        var width = cssW($T, togLen);
                                                                                                                                        $T.css({
                                                                                                                                            width:    width  // account for borders & padding
                                                                                                                                        ,    height:    cssH($T, spacing) // ditto
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 5 hrs to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 4537..4550

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

                                                                                                                    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

                                                                                                                                    else { // east/west
                                                                                                                                        var height = cssH($T, togLen);
                                                                                                                                        $T.css({
                                                                                                                                            height:    height // account for borders & padding
                                                                                                                                        ,    width:    cssW($T, spacing) // ditto
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 5 hrs to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 4523..4536

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

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                            if (isStr(el))
                                                                                                                                $P = $Ps[el];
                                                                                                                            else if ($(el).data("layoutRole"))
                                                                                                                                $P = $(el);
                                                                                                                            else
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 3 hrs to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 4967..4977

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

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                            if (isStr(el))
                                                                                                                                $P = $Ps[el];
                                                                                                                            else if ($(el).data("layoutRole"))
                                                                                                                                $P = $(el);
                                                                                                                            else
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 3 hrs to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 4898..4908

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

                                                                                                                    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
                                                                                                                                $P        = $Ps[pane]
                                                                                                                            ,    $R        = $Rs[pane]
                                                                                                                            ,    $T        = $Ts[pane]
                                                                                                                            ,    o        = options[pane]
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 3 hrs to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 3545..3558

                                                                                                                    Duplicated Code

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

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

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

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                            var 
                                                                                                                                $P        = $Ps[pane]
                                                                                                                            ,    $R        = $Rs[pane]
                                                                                                                            ,    $T        = $Ts[pane]
                                                                                                                            ,    o        = options[pane]
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 3 hrs to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 3377..3390

                                                                                                                    Duplicated Code

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

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

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

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 105.

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                                $R    // if paneSelector is an ID, then create a matching ID for the resizer, eg: "#paneLeft" => "paneLeft-resizer"
                                                                                                                                    .attr("id", paneId ? paneId +"-resizer" : "" )
                                                                                                                                    .data({
                                                                                                                                        parentLayout:    Instance
                                                                                                                                    ,    layoutPane:        Instance[pane]    // NEW pointer to pane-alias-object
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 1 hr to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 2477..2485

                                                                                                                    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

                                                                                                                                    $T    // if paneSelector is an ID, then create a matching ID for the resizer, eg: "#paneLeft" => "#paneLeft-toggler"
                                                                                                                                        .attr("id", paneId ? paneId +"-toggler" : "" )
                                                                                                                                        .data({
                                                                                                                                            parentLayout:    Instance
                                                                                                                                        ,    layoutPane:        Instance[pane]    // NEW pointer to pane-alias-object
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 1 hr to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 2458..2466

                                                                                                                    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

                                                                                                                                $T
                                                                                                                                    .removeClass( tClass+_open +" "+ tClass+_pane+_open )
                                                                                                                                    .addClass( tClass+_closed +" "+ tClass+_pane+_closed )
                                                                                                                                    .attr("title", o.tips.Open) // may be blank
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 1 hr to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 3579..3581

                                                                                                                    Duplicated Code

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

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

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

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 62.

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                                $T    .removeClass( tClass+_closed +" "+ tClass+_pane+_closed )
                                                                                                                                    .addClass( tClass+_open +" "+ tClass+_pane+_open )
                                                                                                                                    .attr("title", o.tips.Close); // may be blank
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 1 hr to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 3408..3411

                                                                                                                    Duplicated Code

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

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

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

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 62.

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                                    case "north":     CSS.top     = sC.inset.top;
                                                                                                                                                    CSS.left     = sC.inset.left;
                                                                                                                                                    CSS.right    = sC.inset.right;
                                                                                                                                                    break;
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 1 hr to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 2401..2404

                                                                                                                    Duplicated Code

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

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

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

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 62.

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                                    case "south":     CSS.bottom    = sC.inset.bottom;
                                                                                                                                                    CSS.left     = sC.inset.left;
                                                                                                                                                    CSS.right     = sC.inset.right;
                                                                                                                                                    break;
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 1 hr to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 2397..2400

                                                                                                                    Duplicated Code

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

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

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

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 62.

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                            else if (dir=="vert") // east or west or center.minWidth
                                                                                                                                avail = sC.innerWidth - ($Ps.west ? o.west.spacing_open : 0) - ($Ps.east ? o.east.spacing_open : 0);
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 1 hr to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 1281..1284

                                                                                                                    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

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

                                                                                                                                if (o.inset && !$.isPlainObject(o.inset)) {
                                                                                                                                    // can specify a single number for equal outset all-around
                                                                                                                                    n = parseInt(o.inset, 10) || 0
                                                                                                                                    o.inset = {
                                                                                                                                        top:    n
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 1 hr to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 1896..1905

                                                                                                                    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

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

                                                                                                                                    else if (!$.isPlainObject(o.outset)) {
                                                                                                                                        // can specify a single number for equal outset all-around
                                                                                                                                        n = parseInt(o.outset, 10) || 0
                                                                                                                                        o.outset = {
                                                                                                                                            top:    n
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 1 hr to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 1873..1882

                                                                                                                    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

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

                                                                                                                            if (dir=="horz") // north or south or center.minHeight
                                                                                                                                avail = sC.innerHeight - ($Ps.north ? o.north.spacing_open : 0) - ($Ps.south ? o.south.spacing_open : 0);
                                                                                                                            else if (dir=="vert") // east or west or center.minWidth
                                                                                                                                avail = sC.innerWidth - ($Ps.west ? o.west.spacing_open : 0) - ($Ps.east ? o.east.spacing_open : 0);
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 1 hr to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 1283..1284

                                                                                                                    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

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

                                                                                                                                    if ($Ps.north && (fix || state.north.tagName=="IFRAME")) 
                                                                                                                                        $Ps.north.css("width", cssW($Ps.north, sC.innerWidth));
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 1 hr to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 4239..4240

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

                                                                                                                    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 ($Ps.south && (fix || state.south.tagName=="IFRAME"))
                                                                                                                                        $Ps.south.css("width", cssW($Ps.south, sC.innerWidth));
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 1 hr to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 4237..4238

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

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                            for (name in paneMethods) {
                                                                                                                                $P.bind("layoutpane"+ name.toLowerCase() +"."+ sID, Instance[ paneMethods[name] || name ]);
                                                                                                                            }
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 1 hr to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 1829..1831

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

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                            for (name in layoutMethods) {
                                                                                                                                $N.bind("layout"+ name.toLowerCase() +"."+ sID, Instance[ layoutMethods[name] || name ]);
                                                                                                                            }
                                                                                                                    Severity: Major
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 1 hr to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 2275..2277

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

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                            var    pane = evtPane.call(this, evt_or_pane)
                                                                                                                            ,    o    = options[pane]
                                                                                                                            ,    s    = state[pane]
                                                                                                                            ,    $P    = $Ps[pane]
                                                                                                                            ,    $R    = $Rs[pane]
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 50 mins to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 3205..3210

                                                                                                                    Duplicated Code

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

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

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

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 52.

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                            var    pane = evtPane.call(this, evt_or_pane)
                                                                                                                            ,    o    = options[pane]
                                                                                                                            ,    s    = state[pane]
                                                                                                                            ,    $P    = $Ps[pane]
                                                                                                                            ,    $R    = $Rs[pane]
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 50 mins to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 3163..3168

                                                                                                                    Duplicated Code

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

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

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

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 52.

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                                case "south":    r.min = top + H - maxSize - rW;
                                                                                                                                                r.max = top + H - minSize - rW;
                                                                                                                                                break;
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 50 mins to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 1383..1385

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

                                                                                                                    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 "east":    r.min = left + W - maxSize - rW;
                                                                                                                                                r.max = left + W - minSize - rW;
                                                                                                                                                break;
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 50 mins to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 1380..1382

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

                                                                                                                    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

                                                                                                                            $.layout.buttons.get(inst, selector, pane, "open")
                                                                                                                                .attr("title", inst.options[pane].tips.Open)
                                                                                                                                .click(function (evt) {
                                                                                                                                    inst.open(pane, !!slide);
                                                                                                                                    evt.stopPropagation();
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 45 mins to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 5722..5727

                                                                                                                    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

                                                                                                                            $.layout.buttons.get(inst, selector, pane, "close")
                                                                                                                                .attr("title", inst.options[pane].tips.Close)
                                                                                                                                .click(function (evt) {
                                                                                                                                    inst.close(pane);
                                                                                                                                    evt.stopPropagation();
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 45 mins to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 5705..5710

                                                                                                                    Duplicated Code

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

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

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

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 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

                                                                                                                    ,    getParentPaneInstance: function (el) {
                                                                                                                            // must pass either a container or pane element
                                                                                                                            var $pane = $.layout.getParentPaneElem(el);
                                                                                                                            return $pane ? $pane.data("layoutPane") : null;
                                                                                                                        }
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 40 mins to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 273..277

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

                                                                                                                    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

                                                                                                                    ,    getParentLayoutInstance: function (el) {
                                                                                                                            // must pass either a container or pane element
                                                                                                                            var $pane = $.layout.getParentPaneElem(el);
                                                                                                                            return $pane ? $pane.data("parentLayout") : null;
                                                                                                                        }
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 40 mins to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 267..271

                                                                                                                    Duplicated Code

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

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

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

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 49.

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                            if (isStr(el)) $E = $Ps[el]; // west
                                                                                                                            else if (!el.jquery) $E = $(el);
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 30 mins to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 1243..1244

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

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

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

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

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

                                                                                                                    Refactorings

                                                                                                                    Further Reading

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

                                                                                                                            if (isStr(el)) $E = $Ps[el]; // west
                                                                                                                            else if (!el.jquery) $E = $(el);
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 30 mins to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 1220..1221

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

                                                                                                                    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

                                                                                                                                    ,    fxExists    = $.effects && ($.effects[fxName] || ($.effects.effect && $.effects.effect[fxName]))
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 30 mins to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 304..304

                                                                                                                    Duplicated Code

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

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

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

                                                                                                                    Tuning

                                                                                                                    This issue has a mass of 45.

                                                                                                                    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

                                                                                                                                else if (pane=="east")
                                                                                                                                    $P.css({ left: sC.inset.left + sC.innerWidth - $P.outerWidth() });
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 30 mins to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 3705..3708

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

                                                                                                                    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 (pane=="south")
                                                                                                                                    $P.css({ top: sC.inset.top + sC.innerHeight - $P.outerHeight() });
                                                                                                                                else if (pane=="east")
                                                                                                                                    $P.css({ left: sC.inset.left + sC.innerWidth - $P.outerWidth() });
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 30 mins to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 3707..3708

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

                                                                                                                    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

                                                                                                                            ,    slide:        $.effects && ($.effects.slide || ($.effects.effect && $.effects.effect.slide)) // default effect
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/deprecated/jquery-layout/jquery.layout.js and 1 other location - About 30 mins to fix
                                                                                                                    packages/deprecated/jquery-layout/jquery.layout.js on lines 2088..2088

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

                                                                                                                    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