angelakuo/citydogshare

View on GitHub
public/assets/jquery-ui-ef9b962e869a815adb51e633eb7d5cc5ddb8bdad94e97ad2461759d77273e9fa.js

Summary

Maintainability
F
2 mos
Test Coverage

File jquery-ui-ef9b962e869a815adb51e633eb7d5cc5ddb8bdad94e97ad2461759d77273e9fa.js has 12607 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*! jQuery UI - v1.11.4 - 2015-03-11
* http://jqueryui.com
* Includes: core.js, widget.js, mouse.js, position.js, accordion.js, autocomplete.js, button.js, datepicker.js, dialog.js, draggable.js, droppable.js, effect.js, effect-blind.js, effect-bounce.js, effect-clip.js, effect-drop.js, effect-explode.js, effect-fade.js, effect-fold.js, effect-highlight.js, effect-puff.js, effect-pulsate.js, effect-scale.js, effect-shake.js, effect-size.js, effect-slide.js, effect-transfer.js, menu.js, progressbar.js, resizable.js, selectable.js, selectmenu.js, slider.js, sortable.js, spinner.js, tabs.js, tooltip.js
* Copyright 2015 jQuery Foundation and other contributors; Licensed MIT */

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

        _create: function() {
            // Some browsers only repeat keydown events, not keypress events,
            // so we use the suppressKeyPress flag to determine if we've already
            // handled the keydown event. #7269
            // Unfortunately the code for & in keypress is the same as the up arrow,

      Function _generateHTML has 169 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          _generateHTML: function(inst) {
              var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
                  controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
                  monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
                  selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,

        Function size has 156 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        var effectSize = $.effects.effect.size = function( o, done ) {
        
            // Create element
            var original, baseline, factor,
                el = $( this ),

          Function parseDate has 149 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              parseDate: function (format, value, settings) {
                  if (format == null || value == null) {
                      throw "Invalid arguments";
                  }
          
          

            Function position has 147 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            $.fn.position = function( options ) {
                if ( !options || !options.of ) {
                    return _position.apply( this, arguments );
                }
            
            

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

                  _create: function() {
              
                      var n, i, handle, axis, hname,
                          that = this,
                          o = this.options;

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

                    _create: function() {
                        this.element.closest( "form" )
                            .unbind( "reset" + this.eventNamespace )
                            .bind( "reset" + this.eventNamespace, formResetHandler );
                
                

                  Function _doKeyDown has 84 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      _doKeyDown: function(event) {
                          var onSelect, dateStr, sel,
                              inst = $.datepicker._getInst(event.target),
                              handled = true,
                              isRTL = inst.dpDiv.is(".ui-datepicker-rtl");

                    Function formatDate has 79 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                        formatDate: function (format, date, settings) {
                            if (!date) {
                                return "";
                            }
                    
                    

                      Function Datepicker has 76 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      function Datepicker() {
                          this._curInst = null; // The current instance in use
                          this._keyEvent = false; // If the last event was a key event
                          this._disabledInputs = []; // List of date picker inputs that have been disabled
                          this._datepickerShowing = false; // True if the popup picker is showing , false if not

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

                            drag: function( event, ui, draggable ) {
                                $.each( draggable.sortables, function() {
                                    var innermostIntersecting = false,
                                        sortable = this;
                        
                        

                          Function _refresh has 76 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                              _refresh: function() {
                                  var maxHeight,
                                      options = this.options,
                                      heightStyle = options.heightStyle,
                                      parent = this.element.parent();

                            Function _mouseStart has 75 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                _mouseStart: function(event, overrideHandle, noActivation) {
                            
                                    var i, body,
                                        o = this.options;
                            
                            

                              Function _mouseDrag has 75 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                  _mouseDrag: function(event) {
                                      var i, item, itemElement, intersection,
                                          o = this.options,
                                          scrolled = false;
                              
                              

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

                                    resize: function( event ) {
                                        var woset, hoset, isParent, isOffsetRelative,
                                            that = $( this ).resizable( "instance" ),
                                            o = that.options,
                                            co = that.containerOffset,

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

                                      _mouseDrag: function(event) {
                                  
                                          this.dragged = true;
                                  
                                          if (this.options.disabled) {

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

                                    $.widget = function( name, base, prototype ) {
                                        var fullName, existingConstructor, constructor, basePrototype,
                                            // proxiedPrototype allows the provided prototype to remain unmodified
                                            // so that it can be used as a mixin for multiple widgets (#8876)
                                            proxiedPrototype = {},

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

                                          _clear: function(event, noPropagation) {
                                      
                                              this.reverting = false;
                                              // We delay all events that have to be triggered to after the point where the placeholder has been removed and
                                              // everything else normalized again

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

                                            _processTabs: function() {
                                                var that = this,
                                                    prevTabs = this.tabs,
                                                    prevAnchors = this.anchors,
                                                    prevPanels = this.panels;

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

                                              _contactContainers: function(event) {
                                                  var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, cur, nearBottom, floating, axis,
                                                      innermostContainer = null,
                                                      innermostIndex = null;
                                          
                                          

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

                                                _create: function() {
                                                    this.activeMenu = this.element;
                                            
                                                    // Flag used to prevent firing of the click handler
                                                    // as the event bubbles up through nested menus

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

                                                  _keydown: function( event ) {
                                                      var match, prev, character, skip,
                                                          preventDefault = true;
                                              
                                                      switch ( event.keyCode ) {

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

                                                    _generatePosition: function( event, constrainPosition ) {
                                                
                                                        var containment, co, top, left,
                                                            o = this.options,
                                                            scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] ),

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

                                                  var effectBounce = $.effects.effect.bounce = function( o, done ) {
                                                      var el = $( this ),
                                                          props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
                                                  
                                                          // defaults:

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

                                                        resize: function() {
                                                            var outerDimensions,
                                                                that = $(this).resizable( "instance" ),
                                                                o = that.options,
                                                                cs = that.size,

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

                                                          _showDatepicker: function(input) {
                                                              input = input.target || input;
                                                              if (input.nodeName.toLowerCase() !== "input") { // find from button/image trigger
                                                                  input = $("input", input.parentNode)[0];
                                                              }

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

                                                                keydown: function( event ) {
                                                                    var allowed, curVal, newVal, step,
                                                                        index = $( event.target ).data( "ui-slider-handle-index" );
                                                        
                                                                    switch ( event.keyCode ) {

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

                                                          var effectExplode = $.effects.effect.explode = function( o, done ) {
                                                          
                                                              var rows = o.pieces ? Math.round( Math.sqrt( o.pieces ) ) : 3,
                                                                  cells = rows,
                                                                  el = $( this ),

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

                                                                drag: function( event, ui, inst ) {
                                                            
                                                                    var ts, bs, ls, rs, l, r, t, b, i, first,
                                                                        o = inst.options,
                                                                        d = o.snapTolerance,

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

                                                                  _open: function( event, target, content ) {
                                                                      var tooltipData, tooltip, delayedShow, a11yContent,
                                                                          positionOption = $.extend( {}, this.options.position );
                                                              
                                                                      if ( !content ) {

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

                                                                    createWrapper: function( element ) {
                                                                
                                                                        // if the element is already wrapped, return it
                                                                        if ( element.parent().is( ".ui-effects-wrapper" )) {
                                                                            return element.parent();

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

                                                                      _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
                                                                              secondary, monthNames, monthNamesShort) {
                                                                  
                                                                          var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear,
                                                                              changeMonth = this._get(inst, "changeMonth"),

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

                                                                        _setContainment: function() {
                                                                    
                                                                            var isUserScrollable, c, ce,
                                                                                o = this.options,
                                                                                document = this.document[ 0 ];

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

                                                                          _setOption: function( key, value ) {
                                                                              var i,
                                                                                  valsLength = 0;
                                                                      
                                                                              if ( key === "range" && this.options.range === true ) {

                                                                        Function _mouseStart has 54 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                        Open

                                                                            _mouseStart: function(event) {
                                                                                var that = this,
                                                                                    options = this.options;
                                                                        
                                                                                this.opos = [ event.pageX, event.pageY ];

                                                                          Function keydown has 54 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                          Open

                                                                                  keydown: function( event ) {
                                                                                      var preventDefault = true;
                                                                                      switch ( event.keyCode ) {
                                                                                          case $.ui.keyCode.TAB:
                                                                                          case $.ui.keyCode.ESCAPE:

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

                                                                                        keydown: function( event ) {
                                                                                            if ( this.element.prop( "readOnly" ) ) {
                                                                                                suppressKeyPress = true;
                                                                                                suppressInput = true;
                                                                                                suppressKeyPressRepeat = true;

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

                                                                                  parse: function( red, green, blue, alpha ) {
                                                                                      if ( red === undefined ) {
                                                                                          this._rgba = [ null, null, null, null ];
                                                                                          return this;
                                                                                      }

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

                                                                                    _refreshValue: function() {
                                                                                        var lastValPercent, valPercent, value, valueMin, valueMax,
                                                                                            oRange = this.options.range,
                                                                                            o = this.options,
                                                                                            that = this,

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

                                                                                      start: function() {
                                                                                          var element, p, co, ch, cw, width, height,
                                                                                              that = $( this ).resizable( "instance" ),
                                                                                              o = that.options,
                                                                                              el = that.element,

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

                                                                                        _animate: function( toShow, toHide, data ) {
                                                                                            var total, easing, duration,
                                                                                                that = this,
                                                                                                adjust = 0,
                                                                                                boxSizing = toShow.css( "box-sizing" ),

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

                                                                                      var effectBlind = $.effects.effect.blind = function( o, done ) {
                                                                                          // Create element
                                                                                          var el = $( this ),
                                                                                              rvertical = /up|down|vertical/,
                                                                                              rpositivemotion = /up|left|vertical|horizontal/,

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

                                                                                            _makeResizable: function() {
                                                                                                var that = this,
                                                                                                    options = this.options,
                                                                                                    handles = options.resizable,
                                                                                                    // .ui-resizable has position: relative defined in the stylesheet

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

                                                                                          $.effects.animateClass = function( value, duration, easing, callback ) {
                                                                                              var o = $.speed( duration, easing, callback );
                                                                                          
                                                                                              return this.queue( function() {
                                                                                                  var animated = $( this ),

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

                                                                                                _setOption: function( key, value ) {
                                                                                                    var isDraggable, isResizable,
                                                                                                        uiDialog = this.uiDialog;
                                                                                            
                                                                                                    if ( key === "dialogClass" ) {

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

                                                                                                  _mouseCapture: function( event ) {
                                                                                                      var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
                                                                                                          that = this,
                                                                                                          o = this.options;
                                                                                              
                                                                                              

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

                                                                                                    _determineDate: function(inst, date, defaultDate) {
                                                                                                        var offsetNumeric = function(offset) {
                                                                                                                var date = new Date();
                                                                                                                date.setDate(date.getDate() + offset);
                                                                                                                return date;

                                                                                                  Function scale has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                  var effectScale = $.effects.effect.scale = function( o, done ) {
                                                                                                  
                                                                                                      // Create element
                                                                                                      var el = $( this ),
                                                                                                          options = $.extend( true, {}, o ),

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

                                                                                                    $.widget.bridge = function( name, object ) {
                                                                                                        var fullName = object.prototype.widgetFullName || name;
                                                                                                        $.fn[ name ] = function( options ) {
                                                                                                            var isMethodCall = typeof options === "string",
                                                                                                                args = widget_slice.call( arguments, 1 ),

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

                                                                                                          _createWrapper: function() {
                                                                                                              this.uiDialog = $("<div>")
                                                                                                                  .addClass( "ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " +
                                                                                                                      this.options.dialogClass )
                                                                                                                  .hide()

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

                                                                                                        var effectFold = $.effects.effect.fold = function( o, done ) {
                                                                                                        
                                                                                                            // Create element
                                                                                                            var el = $( this ),
                                                                                                                props = [ "position", "top", "bottom", "left", "right", "height", "width" ],

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

                                                                                                              _generatePosition: function(event) {
                                                                                                          
                                                                                                                  var top, left,
                                                                                                                      o = this.options,
                                                                                                                      pageX = event.pageX,

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

                                                                                                                _toggle: function( event, eventData ) {
                                                                                                                    var that = this,
                                                                                                                        toShow = eventData.newPanel,
                                                                                                                        toHide = eventData.oldPanel;
                                                                                                            
                                                                                                            

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

                                                                                                                  _tabKeydown: function( event ) {
                                                                                                                      var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
                                                                                                                          selectedIndex = this.tabs.index( focusedTab ),
                                                                                                                          goingForward = true;
                                                                                                              
                                                                                                              

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

                                                                                                                    _destroy: function() {
                                                                                                                        if ( this.xhr ) {
                                                                                                                            this.xhr.abort();
                                                                                                                        }
                                                                                                                
                                                                                                                

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

                                                                                                                      _drawMenu: function() {
                                                                                                                          var that = this;
                                                                                                                  
                                                                                                                          // Create menu
                                                                                                                          this.menu = $( "<ul>", {

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

                                                                                                                        $.fn[ name ] = function( options ) {
                                                                                                                            var isMethodCall = typeof options === "string",
                                                                                                                                args = widget_slice.call( arguments, 1 ),
                                                                                                                                returnValue = this;
                                                                                                                    
                                                                                                                    

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

                                                                                                                          refresh: function() {
                                                                                                                              var menus, items,
                                                                                                                                  that = this,
                                                                                                                                  icon = this.options.icons.submenu,
                                                                                                                                  submenus = this.element.find( this.options.menus );

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

                                                                                                                        var effectShake = $.effects.effect.shake = function( o, done ) {
                                                                                                                        
                                                                                                                            var el = $( this ),
                                                                                                                                props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
                                                                                                                                mode = $.effects.setMode( el, o.mode || "effect" ),

                                                                                                                          Consider simplifying this complex logical expression.
                                                                                                                          Open

                                                                                                                                  if(!(/^(document|window|parent)$/).test(o.containment)) {
                                                                                                                                      ce = $(o.containment)[0];
                                                                                                                                      co = $(o.containment).offset();
                                                                                                                                      over = ($(ce).css("overflow") !== "hidden");
                                                                                                                          
                                                                                                                          

                                                                                                                            Consider simplifying this complex logical expression.
                                                                                                                            Open

                                                                                                                                    if ( ( ( $target[0].id !== $.datepicker._mainDivId &&
                                                                                                                                            $target.parents("#" + $.datepicker._mainDivId).length === 0 &&
                                                                                                                                            !$target.hasClass($.datepicker.markerClassName) &&
                                                                                                                                            !$target.closest("." + $.datepicker._triggerClass).length &&
                                                                                                                                            $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI) ) ) ||

                                                                                                                              Consider simplifying this complex logical expression.
                                                                                                                              Open

                                                                                                                                      if (this.floating && horizontalDirection) {
                                                                                                                                          return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
                                                                                                                                      } else {
                                                                                                                                          return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
                                                                                                                                      }

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

                                                                                                                                    _mouseStart: function(event) {
                                                                                                                                
                                                                                                                                        var curleft, curtop, cursor,
                                                                                                                                            o = this.options,
                                                                                                                                            el = this.element;

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

                                                                                                                                  color.hook = function( hook ) {
                                                                                                                                      var hooks = hook.split( " " );
                                                                                                                                      each( hooks, function( i, hook ) {
                                                                                                                                          jQuery.cssHooks[ hook ] = {
                                                                                                                                              set: function( elem, value ) {

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

                                                                                                                                        _eventHandler: function( event ) {
                                                                                                                                            var options = this.options,
                                                                                                                                                active = this.active,
                                                                                                                                                clicked = $( event.currentTarget ),
                                                                                                                                                clickedIsActive = clicked[ 0 ] === active[ 0 ],

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

                                                                                                                                          _mouseDown: function(event) {
                                                                                                                                              // don't let more than one widget handle mouseStart
                                                                                                                                              if ( mouseHandled ) {
                                                                                                                                                  return;
                                                                                                                                              }

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

                                                                                                                                            _attachments: function(input, inst) {
                                                                                                                                                var showOn, buttonText, buttonImage,
                                                                                                                                                    appendText = this._get(inst, "appendText"),
                                                                                                                                                    isRTL = this._get(inst, "isRTL");
                                                                                                                                        
                                                                                                                                        

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

                                                                                                                                              load: function( index, event ) {
                                                                                                                                                  index = this._getIndex( index );
                                                                                                                                                  var that = this,
                                                                                                                                                      tab = this.tabs.eq( index ),
                                                                                                                                                      anchor = tab.find( ".ui-tabs-anchor" ),

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

                                                                                                                                            $.ui.intersect = (function() {
                                                                                                                                                function isOverAxis( x, reference, size ) {
                                                                                                                                                    return ( x >= reference ) && ( x < ( reference + size ) );
                                                                                                                                                }
                                                                                                                                            
                                                                                                                                            

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

                                                                                                                                                  _respectSize: function( data ) {
                                                                                                                                              
                                                                                                                                                      var o = this._vBoundaries,
                                                                                                                                                          a = this.axis,
                                                                                                                                                          ismaxw = this._isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width),

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

                                                                                                                                                    _optionDatepicker: function(target, name, value) {
                                                                                                                                                        var settings, date, minDate, maxDate,
                                                                                                                                                            inst = this._getInst(target);
                                                                                                                                                
                                                                                                                                                        if (arguments.length === 2 && typeof name === "string") {

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

                                                                                                                                                      close: function( event ) {
                                                                                                                                                          var tooltip,
                                                                                                                                                              that = this,
                                                                                                                                                              target = $( event ? event.currentTarget : this.element ),
                                                                                                                                                              tooltipData = this._find( target );

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

                                                                                                                                                        _on: function( suppressDisabledCheck, element, handlers ) {
                                                                                                                                                            var delegateElement,
                                                                                                                                                                instance = this;
                                                                                                                                                    
                                                                                                                                                            // no suppressDisabledCheck flag, shuffle arguments

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

                                                                                                                                                          drag: function( event, ui, i  ) {
                                                                                                                                                      
                                                                                                                                                              var o = i.options,
                                                                                                                                                                  scrolled = false,
                                                                                                                                                                  scrollParent = i.scrollParentNotHidden[ 0 ],

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

                                                                                                                                                            _drawButton: function() {
                                                                                                                                                                var that = this;
                                                                                                                                                        
                                                                                                                                                                // Associate existing label with the new button
                                                                                                                                                                this.label = $( "label[for='" + this.ids.element + "']" ).attr( "for", this.ids.button );

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

                                                                                                                                                              _toggle: function( data ) {
                                                                                                                                                                  var toShow = data.newPanel,
                                                                                                                                                                      toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
                                                                                                                                                          
                                                                                                                                                                  // handle activating a panel during the animation for another activation

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

                                                                                                                                                                _createPlaceholder: function(that) {
                                                                                                                                                                    that = that || this;
                                                                                                                                                                    var className,
                                                                                                                                                                        o = that.options;
                                                                                                                                                            
                                                                                                                                                            

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

                                                                                                                                                              var effectDrop = $.effects.effect.drop = function( o, done ) {
                                                                                                                                                              
                                                                                                                                                                  var el = $( this ),
                                                                                                                                                                      props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ],
                                                                                                                                                                      mode = $.effects.setMode( el, o.mode || "hide" ),

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

                                                                                                                                                                    drag: function( draggable, event ) {
                                                                                                                                                                
                                                                                                                                                                        // If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
                                                                                                                                                                        if ( draggable.options.refreshPositions ) {
                                                                                                                                                                            $.ui.ddmanager.prepareOffsets( draggable, event );

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

                                                                                                                                                                      _possibleChars: function (format) {
                                                                                                                                                                          var iFormat,
                                                                                                                                                                              chars = "",
                                                                                                                                                                              literal = false,
                                                                                                                                                                              // Check whether a format character is doubled

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

                                                                                                                                                                    var effectClip = $.effects.effect.clip = function( o, done ) {
                                                                                                                                                                        // Create element
                                                                                                                                                                        var el = $( this ),
                                                                                                                                                                            props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
                                                                                                                                                                            mode = $.effects.setMode( el, o.mode || "hide" ),

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

                                                                                                                                                                          _mouseCapture: function(event, overrideHandle) {
                                                                                                                                                                              var currentItem = null,
                                                                                                                                                                                  validHandle = false,
                                                                                                                                                                                  that = this;
                                                                                                                                                                      
                                                                                                                                                                      

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

                                                                                                                                                                        var effectSlide = $.effects.effect.slide = function( o, done ) {
                                                                                                                                                                        
                                                                                                                                                                            // Create element
                                                                                                                                                                            var el = $( this ),
                                                                                                                                                                                props = [ "position", "top", "bottom", "left", "right", "width", "height" ],

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

                                                                                                                                                                              _dialogDatepicker: function(input, date, onSelect, settings, pos) {
                                                                                                                                                                                  var id, browserWidth, browserHeight, scrollX, scrollY,
                                                                                                                                                                                      inst = this._dialogInst; // internal instance
                                                                                                                                                                          
                                                                                                                                                                                  if (!inst) {

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

                                                                                                                                                                                _hideDatepicker: function(input) {
                                                                                                                                                                                    var showAnim, duration, postProcess, onClose,
                                                                                                                                                                                        inst = this._curInst;
                                                                                                                                                                            
                                                                                                                                                                                    if (!inst || (input && inst !== $.data(input, "datepicker"))) {

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

                                                                                                                                                                              var effectPulsate = $.effects.effect.pulsate = function( o, done ) {
                                                                                                                                                                                  var elem = $( this ),
                                                                                                                                                                                      mode = $.effects.setMode( elem, o.mode || "show" ),
                                                                                                                                                                                      show = mode === "show",
                                                                                                                                                                                      hide = mode === "hide",

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

                                                                                                                                                                                    _createTitlebar: function() {
                                                                                                                                                                                        var uiDialogTitle;
                                                                                                                                                                                
                                                                                                                                                                                        this.uiDialogTitlebar = $( "<div>" )
                                                                                                                                                                                            .addClass( "ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix" )

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

                                                                                                                                                                                      _resetButton: function() {
                                                                                                                                                                                          if ( this.type === "input" ) {
                                                                                                                                                                                              if ( this.options.label ) {
                                                                                                                                                                                                  this.element.val( this.options.label );
                                                                                                                                                                                              }

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

                                                                                                                                                                                        _mouseStart: function(event) {
                                                                                                                                                                                    
                                                                                                                                                                                            var o = this.options;
                                                                                                                                                                                    
                                                                                                                                                                                            //Create and append the visible helper

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

                                                                                                                                                                                          effect: function( /* effect, options, speed, callback */ ) {
                                                                                                                                                                                              var args = _normalizeArguments.apply( this, arguments ),
                                                                                                                                                                                                  mode = args.mode,
                                                                                                                                                                                                  queue = args.queue,
                                                                                                                                                                                                  effectMethod = $.effects.effect[ args.effect ];

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

                                                                                                                                                                                            cancel: function() {
                                                                                                                                                                                        
                                                                                                                                                                                                if(this.dragging) {
                                                                                                                                                                                        
                                                                                                                                                                                                    this._mouseUp({ target: null });

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

                                                                                                                                                                                              _slide: function( event, index, newVal ) {
                                                                                                                                                                                                  var otherVal,
                                                                                                                                                                                                      newValues,
                                                                                                                                                                                                      allowed;
                                                                                                                                                                                          
                                                                                                                                                                                          

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

                                                                                                                                                                                                _makeDraggable: function() {
                                                                                                                                                                                                    var that = this,
                                                                                                                                                                                                        options = this.options;
                                                                                                                                                                                            
                                                                                                                                                                                                    function filteredUi( ui ) {

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

                                                                                                                                                                                                  _eventHandler: function( event ) {
                                                                                                                                                                                                      var options = this.options,
                                                                                                                                                                                                          active = this.active,
                                                                                                                                                                                                          anchor = $( event.currentTarget ),
                                                                                                                                                                                                          tab = anchor.closest( "li" ),

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

                                                                                                                                                                                                    refreshPositions: function(fast) {
                                                                                                                                                                                                
                                                                                                                                                                                                        // Determine whether items are being displayed horizontally
                                                                                                                                                                                                        this.floating = this.items.length ?
                                                                                                                                                                                                            this.options.axis === "x" || this._isFloating( this.items[ 0 ].item ) :

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

                                                                                                                                                                                                      _keydown: function( event ) {
                                                                                                                                                                                                          if ( event.altKey || event.ctrlKey ) {
                                                                                                                                                                                                              return;
                                                                                                                                                                                                          }
                                                                                                                                                                                                  
                                                                                                                                                                                                  

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

                                                                                                                                                                                                        _mouseStop: function(event) {
                                                                                                                                                                                                    
                                                                                                                                                                                                            this.resizing = false;
                                                                                                                                                                                                            var pr, ista, soffseth, soffsetw, s, left, top,
                                                                                                                                                                                                                o = this.options, that = this;

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

                                                                                                                                                                                                      function _normalizeArguments( effect, options, speed, callback ) {
                                                                                                                                                                                                      
                                                                                                                                                                                                          // allow passing all options as the first parameter
                                                                                                                                                                                                          if ( $.isPlainObject( effect ) ) {
                                                                                                                                                                                                              options = effect;

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

                                                                                                                                                                                                                top: function( position, data ) {
                                                                                                                                                                                                                    var within = data.within,
                                                                                                                                                                                                                        withinOffset = within.offset.top + within.scrollTop,
                                                                                                                                                                                                                        outerHeight = within.height,
                                                                                                                                                                                                                        offsetTop = within.isWindow ? within.scrollTop : within.offset.top,

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

                                                                                                                                                                                                              _createRange: function() {
                                                                                                                                                                                                                  var options = this.options,
                                                                                                                                                                                                                      classes = "";
                                                                                                                                                                                                          
                                                                                                                                                                                                                  if ( options.range ) {

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

                                                                                                                                                                                                                _size: function() {
                                                                                                                                                                                                                    // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
                                                                                                                                                                                                                    // divs will both have width and height set, so we need to reset them
                                                                                                                                                                                                                    var nonContentHeight, minContentHeight, maxContentHeight,
                                                                                                                                                                                                                        options = this.options;

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

                                                                                                                                                                                                                  _updateDatepicker: function(inst) {
                                                                                                                                                                                                                      this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
                                                                                                                                                                                                                      datepicker_instActive = inst; // for delegate hover events
                                                                                                                                                                                                                      inst.dpDiv.empty().append(this._generateHTML(inst));
                                                                                                                                                                                                                      this._attachHandlers(inst);

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

                                                                                                                                                                                                                    _refreshItems: function(event) {
                                                                                                                                                                                                                
                                                                                                                                                                                                                        this.items = [];
                                                                                                                                                                                                                        this.containers = [this];
                                                                                                                                                                                                                
                                                                                                                                                                                                                

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

                                                                                                                                                                                                                      _attachHandlers: function(inst) {
                                                                                                                                                                                                                          var stepMonths = this._get(inst, "stepMonths"),
                                                                                                                                                                                                                              id = "#" + inst.id.replace( /\\\\/g, "\\" );
                                                                                                                                                                                                                          inst.dpDiv.find("[data-handler]").map(function () {
                                                                                                                                                                                                                              var handler = {

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

                                                                                                                                                                                                                            left: function( position, data ) {
                                                                                                                                                                                                                                var within = data.within,
                                                                                                                                                                                                                                    withinOffset = within.offset.left + within.scrollLeft,
                                                                                                                                                                                                                                    outerWidth = within.width,
                                                                                                                                                                                                                                    offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,

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

                                                                                                                                                                                                                                  offsetString = function(offset) {
                                                                                                                                                                                                                                      try {
                                                                                                                                                                                                                                          return $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
                                                                                                                                                                                                                                              offset, $.datepicker._getFormatConfig(inst));
                                                                                                                                                                                                                                      }

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

                                                                                                                                                                                                                            option: function( key, value ) {
                                                                                                                                                                                                                                var options = key,
                                                                                                                                                                                                                                    parts,
                                                                                                                                                                                                                                    curOption,
                                                                                                                                                                                                                                    i;

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

                                                                                                                                                                                                                              open: function( event ) {
                                                                                                                                                                                                                                  var that = this,
                                                                                                                                                                                                                                      target = $( event ? event.target : this.element )
                                                                                                                                                                                                                                          // we need closest here due to mouseover bubbling,
                                                                                                                                                                                                                                          // but always pointing at the same event target

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

                                                                                                                                                                                                                                stop: function( event ) {
                                                                                                                                                                                                                                    var that = $(this).resizable( "instance" ),
                                                                                                                                                                                                                                        o = that.options,
                                                                                                                                                                                                                                        pr = that._proportionallyResizeElements,
                                                                                                                                                                                                                                        ista = pr.length && (/textarea/i).test(pr[0].nodeName),

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

                                                                                                                                                                                                                                  _createButtons: function() {
                                                                                                                                                                                                                                      var that = this,
                                                                                                                                                                                                                                          buttons = this.options.buttons;
                                                                                                                                                                                                                              
                                                                                                                                                                                                                                      // if we already have a button pane, remove it

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

                                                                                                                                                                                                                                spaces.hsla.to = function( rgba ) {
                                                                                                                                                                                                                                    if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
                                                                                                                                                                                                                                        return [ null, null, null, rgba[ 3 ] ];
                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                    var r = rgba[ 0 ] / 255,

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

                                                                                                                                                                                                                                      _determineButtonType: function() {
                                                                                                                                                                                                                                          var ancestor, labelSelector, checked;
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                          if ( this.element.is("[type=checkbox]") ) {
                                                                                                                                                                                                                                              this.type = "checkbox";

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

                                                                                                                                                                                                                                        _create: function() {
                                                                                                                                                                                                                                            this.originalCss = {
                                                                                                                                                                                                                                                display: this.element[ 0 ].style.display,
                                                                                                                                                                                                                                                width: this.element[ 0 ].style.width,
                                                                                                                                                                                                                                                minHeight: this.element[ 0 ].style.minHeight,

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

                                                                                                                                                                                                                                          transition: function( other, distance ) {
                                                                                                                                                                                                                                              var end = color( other ),
                                                                                                                                                                                                                                                  spaceName = end._space(),
                                                                                                                                                                                                                                                  space = spaces[ spaceName ],
                                                                                                                                                                                                                                                  startColor = this.alpha() === 0 ? color( "transparent" ) : this,

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

                                                                                                                                                                                                                                            _refreshValue: function() {
                                                                                                                                                                                                                                                var value = this.options.value,
                                                                                                                                                                                                                                                    percentage = this._percentage();
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                this.valueDiv

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

                                                                                                                                                                                                                                                  complete: function() {
                                                                                                                                                                                                                                                      if ( el.to.opacity === 0 ) {
                                                                                                                                                                                                                                                          el.css( "opacity", el.from.opacity );
                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                      if ( mode === "hide" ) {

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

                                                                                                                                                                                                                                                _drop: function( event, custom ) {
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                    var draggable = custom || $.ui.ddmanager.current,
                                                                                                                                                                                                                                                        childrenIntersection = false;
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            

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

                                                                                                                                                                                                                                                  _initialActive: function() {
                                                                                                                                                                                                                                                      var active = this.options.active,
                                                                                                                                                                                                                                                          collapsible = this.options.collapsible,
                                                                                                                                                                                                                                                          locationHash = location.hash.substring( 1 );
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              

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

                                                                                                                                                                                                                                                    _refresh: function() {
                                                                                                                                                                                                                                                        this._setupDisabled( this.options.disabled );
                                                                                                                                                                                                                                                        this._setupEvents( this.options.event );
                                                                                                                                                                                                                                                        this._setupHeightStyle( this.options.heightStyle );
                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                

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

                                                                                                                                                                                                                                                      _create: function() {
                                                                                                                                                                                                                                                          var selectees,
                                                                                                                                                                                                                                                              that = this;
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                          this.element.addClass("ui-selectable");

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

                                                                                                                                                                                                                                                    var effectTransfer = $.effects.effect.transfer = function( o, done ) {
                                                                                                                                                                                                                                                        var elem = $( this ),
                                                                                                                                                                                                                                                            target = $( o.to ),
                                                                                                                                                                                                                                                            targetFixed = target.css( "position" ) === "fixed",
                                                                                                                                                                                                                                                            body = $("body"),

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

                                                                                                                                                                                                                                                          _destroy: function() {
                                                                                                                                                                                                                                                              // Destroy (sub)menus
                                                                                                                                                                                                                                                              this.element
                                                                                                                                                                                                                                                                  .removeAttr( "aria-activedescendant" )
                                                                                                                                                                                                                                                                  .find( ".ui-menu" ).addBack()

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

                                                                                                                                                                                                                                                        var effectPuff = $.effects.effect.puff = function( o, done ) {
                                                                                                                                                                                                                                                            var elem = $( this ),
                                                                                                                                                                                                                                                                mode = $.effects.setMode( elem, o.mode || "hide" ),
                                                                                                                                                                                                                                                                hide = mode === "hide",
                                                                                                                                                                                                                                                                percent = parseInt( o.percent, 10 ) || 150,

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

                                                                                                                                                                                                                                                              _initSource: function() {
                                                                                                                                                                                                                                                                  var array, url,
                                                                                                                                                                                                                                                                      that = this;
                                                                                                                                                                                                                                                                  if ( $.isArray( this.options.source ) ) {
                                                                                                                                                                                                                                                                      array = this.options.source;

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

                                                                                                                                                                                                                                                                values: function( index, newValue ) {
                                                                                                                                                                                                                                                                    var vals,
                                                                                                                                                                                                                                                                        newValues,
                                                                                                                                                                                                                                                                        i;
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            

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

                                                                                                                                                                                                                                                                  _mouseDrag: function(event) {
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                      var data, props,
                                                                                                                                                                                                                                                                          smp = this.originalMousePosition,
                                                                                                                                                                                                                                                                          a = this.axis,

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

                                                                                                                                                                                                                                                                var effectHighlight = $.effects.effect.highlight = function( o, done ) {
                                                                                                                                                                                                                                                                    var elem = $( this ),
                                                                                                                                                                                                                                                                        props = [ "backgroundImage", "backgroundColor", "opacity" ],
                                                                                                                                                                                                                                                                        mode = $.effects.setMode( elem, o.mode || "show" ),
                                                                                                                                                                                                                                                                        animation = {

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

                                                                                                                                                                                                                                                                      _createOverlay: function() {
                                                                                                                                                                                                                                                                          if ( !this.options.modal ) {
                                                                                                                                                                                                                                                                              return;
                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  

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

                                                                                                                                                                                                                                                                        _createWidget: function( options, element ) {
                                                                                                                                                                                                                                                                            element = $( element || this.defaultElement || this )[ 0 ];
                                                                                                                                                                                                                                                                            this.element = $( element );
                                                                                                                                                                                                                                                                            this.uuid = widget_uuid++;
                                                                                                                                                                                                                                                                            this.eventNamespace = "." + this.widgetName + this.uuid;

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

                                                                                                                                                                                                                                                                              left: function( position, data ) {
                                                                                                                                                                                                                                                                                  var within = data.within,
                                                                                                                                                                                                                                                                                      withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
                                                                                                                                                                                                                                                                                      outerWidth = within.width,
                                                                                                                                                                                                                                                                                      collisionPosLeft = position.left - data.collisionPosition.marginLeft,

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

                                                                                                                                                                                                                                                                        function getDimensions( elem ) {
                                                                                                                                                                                                                                                                            var raw = elem[0];
                                                                                                                                                                                                                                                                            if ( raw.nodeType === 9 ) {
                                                                                                                                                                                                                                                                                return {
                                                                                                                                                                                                                                                                                    width: elem.width(),

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

                                                                                                                                                                                                                                                                              _updateVirtualBoundaries: function(forceAspectRatio) {
                                                                                                                                                                                                                                                                                  var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
                                                                                                                                                                                                                                                                                      o = this.options;
                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                  b = {

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

                                                                                                                                                                                                                                                                                _setOption: function( key, value ) {
                                                                                                                                                                                                                                                                                    if ( key === "active" ) {
                                                                                                                                                                                                                                                                                        // _activate() will handle invalid values and update this.options
                                                                                                                                                                                                                                                                                        this._activate( value );
                                                                                                                                                                                                                                                                                        return;

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

                                                                                                                                                                                                                                                                                      top: function( position, data ) {
                                                                                                                                                                                                                                                                                          var within = data.within,
                                                                                                                                                                                                                                                                                              withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
                                                                                                                                                                                                                                                                                              outerHeight = data.within.height,
                                                                                                                                                                                                                                                                                              collisionPosTop = position.top - data.collisionPosition.marginTop,

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

                                                                                                                                                                                                                                                                                    refresh: function() {
                                                                                                                                                                                                                                                                                        //See #8237 & #8828
                                                                                                                                                                                                                                                                                        var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" );
                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                        if ( isDisabled !== this.options.disabled ) {

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

                                                                                                                                                                                                                                                                                      _setupHeightStyle: function( heightStyle ) {
                                                                                                                                                                                                                                                                                          var maxHeight,
                                                                                                                                                                                                                                                                                              parent = this.element.parent();
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                          if ( heightStyle === "fill" ) {

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

                                                                                                                                                                                                                                                                                        _destroy: function() {
                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                            this._mouseDestroy();
                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                            var wrapper,

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

                                                                                                                                                                                                                                                                                                  set: function( elem, value ) {
                                                                                                                                                                                                                                                                                                      var parsed, curElem,
                                                                                                                                                                                                                                                                                                          backgroundColor = "";
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {

                                                                                                                                                                                                                                                                                        Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                                                if ((this.options.revert === "invalid" && !dropped) || (this.options.revert === "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
                                                                                                                                                                                                                                                                                                    $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
                                                                                                                                                                                                                                                                                                        if (that._trigger("stop", event) !== false) {
                                                                                                                                                                                                                                                                                                            that._clear();
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                          Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                                                      if (!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
                                                                                                                                                                                                                                                                                                          (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                            Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                                                    if ( this.options.tolerance === "pointer" ||
                                                                                                                                                                                                                                                                                                        this.options.forcePointerForContainers ||
                                                                                                                                                                                                                                                                                                        (this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
                                                                                                                                                                                                                                                                                                    ) {
                                                                                                                                                                                                                                                                                                        return isOverElement;

                                                                                                                                                                                                                                                                                              Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                                                      if ($.datepicker._datepickerShowing) {
                                                                                                                                                                                                                                                                                                          switch (event.keyCode) {
                                                                                                                                                                                                                                                                                                              case 9: $.datepicker._hideDatepicker();
                                                                                                                                                                                                                                                                                                                      handled = false;
                                                                                                                                                                                                                                                                                                                      break; // hide on tab out

                                                                                                                                                                                                                                                                                                Function _generateMonthYearHeader has 8 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                                                    _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
                                                                                                                                                                                                                                                                                                            secondary, monthNames, monthNamesShort) {

                                                                                                                                                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                                                                                          switch (col) {
                                                                                                                                                                                                                                                                                                                              case 0: calender += " ui-datepicker-group-first";
                                                                                                                                                                                                                                                                                                                                  cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break;
                                                                                                                                                                                                                                                                                                                              case numMonths[1]-1: calender += " ui-datepicker-group-last";
                                                                                                                                                                                                                                                                                                                                  cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break;

                                                                                                                                                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                                if (lookAhead("'")) {
                                                                                                                                                                                                                                                                                                                                    output += "'";
                                                                                                                                                                                                                                                                                                                                } else {
                                                                                                                                                                                                                                                                                                                                    literal = true;
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                      Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                                                                                          if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
                                                                                                                                                                                                                                                                                                                              curElem = hook === "backgroundColor" ? elem.parentNode : elem;
                                                                                                                                                                                                                                                                                                                              while (
                                                                                                                                                                                                                                                                                                                                  (backgroundColor === "" || backgroundColor === "transparent") &&
                                                                                                                                                                                                                                                                                                                                  curElem && curElem.style

                                                                                                                                                                                                                                                                                                        Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                                                                    if (
                                                                                                                                                                                                                                                                                                                        inst.options.greedy &&
                                                                                                                                                                                                                                                                                                                        !inst.options.disabled &&
                                                                                                                                                                                                                                                                                                                        inst.options.scope === draggable.options.scope &&
                                                                                                                                                                                                                                                                                                                        inst.accept.call( inst.element[ 0 ], ( draggable.currentItem || draggable.element ) ) &&

                                                                                                                                                                                                                                                                                                          Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                                                                      if ( ( this.options.values.length === 2 && this.options.range === true ) &&
                                                                                                                                                                                                                                                                                                                              ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
                                                                                                                                                                                                                                                                                                                          ) {
                                                                                                                                                                                                                                                                                                                          newVal = otherVal;
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                            Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                                                                if ( o.mode === "toggle" && mode === "show" ) {
                                                                                                                                                                                                                                                                                                                    el.from = o.to || zero;
                                                                                                                                                                                                                                                                                                                    el.to = o.from || original;
                                                                                                                                                                                                                                                                                                                } else {
                                                                                                                                                                                                                                                                                                                    el.from = o.from || ( mode === "show" ? zero : original );

                                                                                                                                                                                                                                                                                                              Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                                                                      if ( tab.hasClass( "ui-state-disabled" ) ||
                                                                                                                                                                                                                                                                                                                              // tab is already loading
                                                                                                                                                                                                                                                                                                                              tab.hasClass( "ui-tabs-loading" ) ||
                                                                                                                                                                                                                                                                                                                              // can't switch durning an animation
                                                                                                                                                                                                                                                                                                                              this.running ||

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

                                                                                                                                                                                                                                                                                                                    _dialogDatepicker: function(input, date, onSelect, settings, pos) {

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

                                                                                                                                                                                                                                                                                                                      switchClass: function( remove, add, speed, easing, callback) {

                                                                                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                            return true;

                                                                                                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                                                                                              return false;

                                                                                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                                                                                    return;

                                                                                                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                                                                              return false;

                                                                                                                                                                                                                                                                                                                            There are no issues that match your filters.

                                                                                                                                                                                                                                                                                                                            Category
                                                                                                                                                                                                                                                                                                                            Status