spotweb/spotweb

View on GitHub
js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js

Summary

Maintainability
F
2 mos
Test Coverage

File jquery.mobile-1.4.5.js has 10421 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*!
* jQuery Mobile 1.4.5
* Git HEAD hash: 68e55e78b292634d3991c795f06f5e37a512decc <> Date: Fri Oct 31 2014 17:33:30 UTC
* http://jquerymobile.com
*
Severity: Major
Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 mo to fix

    Function _registerInternalEvents has 183 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        $.mobile._registerInternalEvents = function() {
            var getAjaxFormData = function( $form, calculateOnly ) {
                var url, ret = true, formData, vclickedName, method;
                if ( !$.mobile.ajaxEnabled ||
                        // test that the form is, itself, ajax false
    Severity: Major
    Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 7 hrs to fix

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

              transition: function( toPage, triggerData, settings ) {
                  var fromPage, url, pageUrl, fileUrl,
                      active, activeIsInitialPage,
                      historyDir, pageTitle, isDialog,
                      alreadyThere, newPageTitle,
      Severity: Major
      Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 5 hrs to fix

        Consider simplifying this complex logical expression.
        Open

            if (
                // iOS 4.3 and older : Platform is iPhone/Pad/Touch and Webkit version is less than 534 (ios5)
                ( ( platform.indexOf( "iPhone" ) > -1 || platform.indexOf( "iPad" ) > -1  || platform.indexOf( "iPod" ) > -1 ) && wkversion && wkversion < 534 ) ||
                // Opera Mini
                ( w.operamini && ({}).toString.call( w.operamini ) === "[object OperaMini]" ) ||
        Severity: Critical
        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 5 hrs to fix

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

              refresh: function( val, isfromControl, preventInputUpdate ) {
                  // NOTE: we don't return here because we want to support programmatic
                  //       alteration of the input value, which should still update the slider
          
                  var self = this,
          Severity: Major
          Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 4 hrs to fix

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

                _create: function() {
            
                    // TODO: Each of these should have comments explain what they're for
                    var self = this,
                        control = this.element,
            Severity: Major
            Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 4 hrs to fix

              Function _buildList has 85 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  _buildList: function() {
                      var self = this,
                          o = this.options,
                          placeholder = this.placeholder,
                          needPlaceholder = true,
              Severity: Major
              Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 3 hrs to fix

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

                    refresh: function( create ) {
                        var buttonClass, pos, numli, item, itemClass, itemTheme, itemIcon, icon, a,
                            isDivider, startCount, newStartCount, value, last, splittheme, splitThemeClass, spliticon,
                            altButtonClass, dividerTheme, li,
                            o = this.options,
                Severity: Major
                Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 3 hrs to fix

                  Function build has 82 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      build: function() {
                          var selectId, popupId, dialogId, label, thisPage, isMultiple, menuId,
                              themeAttr, overlayTheme, overlayThemeAttr, dividerThemeAttr,
                              menuPage, listbox, list, header, headerTitle, menuPageContent,
                              menuPageClose, headerClose,
                  Severity: Major
                  Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 3 hrs to fix

                    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 = {},
                    Severity: Major
                    Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 2 hrs to fix

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

                          _applyOptions: function( options ) {
                              var isCollapsed, newTheme, oldTheme, hasCorners, hasIcon,
                                  elem = this.element,
                                  currentOpts = this._renderedOptions,
                                  ui = this._ui,
                      Severity: Major
                      Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 2 hrs to fix

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

                                load: function( url, options ) {
                                    // This function uses deferred notifications to let callers
                                    // know when the content is done loading, or if an error has occurred.
                                    var deferred = ( options && options.deferred ) || $.Deferred(),
                        
                        
                        Severity: Major
                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 2 hrs to fix

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

                              open: function( immediate ) {
                                  if ( !this._open ) {
                                      var self = this,
                                          o = self.options,
                          
                          
                          Severity: Major
                          Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 2 hrs to fix

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

                                _processTabs: function() {
                                    var that = this;
                            
                                    this.tablist = this._getList()
                                        .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
                            Severity: Major
                            Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 2 hrs to fix

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

                                      var getAjaxFormData = function( $form, calculateOnly ) {
                                          var url, ret = true, formData, vclickedName, method;
                                          if ( !$.mobile.ajaxEnabled ||
                                                  // test that the form is, itself, ajax false
                                                  $form.is( ":jqmData(ajax='false')" ) ||
                              Severity: Major
                              Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 2 hrs to fix

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

                                    build: function() {
                                        var self = this;
                                
                                        this.select
                                            .appendTo( self.button )
                                Severity: Minor
                                Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                          _create: function() {
                                              var $el = this.element,
                                              elClass = this.options.mini ? "ui-rangeslider ui-mini" : "ui-rangeslider",
                                              _inputFirst = $el.find( "input" ).first(),
                                              _inputLast = $el.find( "input" ).last(),
                                  Severity: Minor
                                  Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                        _toggle: function( event, eventData ) {
                                            var that = this,
                                                toShow = eventData.newPanel,
                                                toHide = eventData.oldPanel;
                                    
                                    
                                    Severity: Minor
                                    Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                          _create: function() {
                                              var input = this.element,
                                                  o = this.options,
                                                  inheritAttr = function( input, dataAttr ) {
                                                      return input.jqmData( dataAttr ) ||
                                      Severity: Minor
                                      Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                            close: function( immediate ) {
                                                if ( this._open ) {
                                                    var self = this,
                                                        o = this.options,
                                        
                                        
                                        Severity: Minor
                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                          function getSpecialEventObject( eventType ) {
                                              var realType = eventType.substr( 1 );
                                          
                                              return {
                                                  setup: function(/* data, namespace */) {
                                          Severity: Minor
                                          Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                    initializePage: function() {
                                                        // find present pages
                                                        var path = $.mobile.path,
                                                            $pages = $( ":jqmData(role='page'), :jqmData(role='dialog')" ),
                                                            hash = path.stripHash( path.stripQueryParams(path.parseLocation().hash) ),
                                            Severity: Minor
                                            Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                              function classNameToOptions( classes ) {
                                                  var idx, map, unknownClass,
                                                      alreadyEnhanced = false,
                                                      noIcon = true,
                                                      o = {
                                              Severity: Minor
                                              Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

                                                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;
                                                
                                                
                                                Severity: Minor
                                                Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                          setup: function() {
                                                              var events,
                                                                  thisObject = this,
                                                                  $this = $( thisObject ),
                                                                  context = {};
                                                  Severity: Minor
                                                  Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                        _destroy: function() {
                                                            if ( this.xhr ) {
                                                                this.xhr.abort();
                                                            }
                                                    
                                                    
                                                    Severity: Minor
                                                    Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

                                                      Function bridge has 43 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 = slice.call( arguments, 1 ),
                                                      Severity: Minor
                                                      Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                    squash: function( url, resolutionUrl ) {
                                                                        var href, cleanedUrl, search, stateIndex, docUrl,
                                                                            isPath = this.isPath( url ),
                                                                            uri = this.parseUrl( url ),
                                                                            preservedHash = uri.hash,
                                                        Severity: Minor
                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                              _create: function() {
                                                                  var theElement = this.element,
                                                                      myId = theElement.attr( "id" ),
                                                                      currentOptions = this.options;
                                                          
                                                          
                                                          Severity: Minor
                                                          Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                _enhance: function() {
                                                                    var flipswitch = $( "<div>" ),
                                                                        options = this.options,
                                                                        element = this.element,
                                                                        theme = options.theme ? options.theme : "inherit",
                                                            Severity: Minor
                                                            Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                  open: function( options ) {
                                                                      var url, hashkey, activePage, currentIsDialog, hasHash, urlHistory,
                                                                          self = this,
                                                                          currentOptions = this.options;
                                                              
                                                              
                                                              Severity: Minor
                                                              Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                    _setOptions: function( newOptions ) {
                                                                        var currentOptions = this.options,
                                                                            theElement = this.element,
                                                                            screen = this._ui.screen;
                                                                
                                                                
                                                                Severity: Minor
                                                                Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                      $.fn[ name ] = function( options ) {
                                                                          var isMethodCall = typeof options === "string",
                                                                              args = slice.call( arguments, 1 ),
                                                                              returnValue = this;
                                                                  
                                                                  
                                                                  Severity: Minor
                                                                  Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                            _change: function( event ) {
                                                                                if ( event.type === "keyup" ) {
                                                                                    this._updateHighlight();
                                                                                    return false;
                                                                                }
                                                                    Severity: Minor
                                                                    Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                          _setTolerance: function( value ) {
                                                                              var tol = { t: 30, r: 15, b: 30, l: 15 },
                                                                                  ar;
                                                                      
                                                                              if ( value !== undefined ) {
                                                                      Severity: Minor
                                                                      Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                            _create: function() {
                                                                                this._preExtension();
                                                                        
                                                                                this.button = this._button();
                                                                        
                                                                        
                                                                        Severity: Minor
                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

                                                                          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
                                                                          Severity: Minor
                                                                          Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                            $.fn.grid = function( options ) {
                                                                                return this.each(function() {
                                                                            
                                                                                    var $this = $( this ),
                                                                                        o = $.extend({
                                                                            Severity: Minor
                                                                            Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                  _enhance: function( elem, ui ) {
                                                                                      var iconclass,
                                                                                          opts = this._renderedOptions,
                                                                                          contentThemeClass = this._themeClassFromOption( "ui-body-", opts.contentTheme );
                                                                              
                                                                              
                                                                              Severity: Minor
                                                                              Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                        setup: function() {
                                                                                            var thisObject = this,
                                                                                                $this = $( thisObject ),
                                                                                                isTaphold = false;
                                                                                
                                                                                
                                                                                Severity: Minor
                                                                                Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                      _placementCoords: function( desired ) {
                                                                                          var state, best, params, elOffset, bgRef,
                                                                                              optionValue = this.options.arrow,
                                                                                              ar = this._ui.arrow;
                                                                                  
                                                                                  
                                                                                  Severity: Minor
                                                                                  Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                        _handleKeydown: function( event ) {
                                                                                            var index = this._value();
                                                                                            if ( this.options.disabled ) {
                                                                                                return;
                                                                                            }
                                                                                    Severity: Minor
                                                                                    Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                              popstate: function( event ) {
                                                                                                  var hash, state;
                                                                                      
                                                                                                  // Partly to support our test suite which manually alters the support
                                                                                                  // value to test hashchange. Partly to prevent all around weirdness
                                                                                      Severity: Minor
                                                                                      Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                            _desiredCoords: function( openOptions ) {
                                                                                                var offset,
                                                                                                    dst = null,
                                                                                                    windowCoordinates = getWindowCoordinates( this.window ),
                                                                                                    x = openOptions.x,
                                                                                        Severity: Minor
                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

                                                                                          Function load has 36 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" ),
                                                                                          Severity: Minor
                                                                                          Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                    enhanceWithin: function() {
                                                                                                        var index,
                                                                                                            widgetElements = {},
                                                                                                            keepNative = $.mobile.page.prototype.keepNativeSelector(),
                                                                                                            that = this;
                                                                                            Severity: Minor
                                                                                            Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                  _destroy: function() {
                                                                                                      var otherPanels,
                                                                                                      o = this.options,
                                                                                                      multiplePanels = ( $( "body > :mobile-panel" ).length + $.mobile.activePage.find( ":mobile-panel" ).length ) > 1;
                                                                                              
                                                                                              
                                                                                              Severity: Minor
                                                                                              Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                    _create: function() {
                                                                                                
                                                                                                        var $navbar = this.element,
                                                                                                            $navbtns = $navbar.find( "a, button" ),
                                                                                                            iconpos = $navbtns.filter( ":jqmData(icon)" ).length ? this.options.iconpos : undefined;
                                                                                                Severity: Minor
                                                                                                Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                      _open: function( options ) {
                                                                                                          var openOptions = $.extend( {}, this.options, options ),
                                                                                                              // TODO move blacklist to private method
                                                                                                              androidBlacklist = ( function() {
                                                                                                                  var ua = navigator.userAgent,
                                                                                                  Severity: Minor
                                                                                                  Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                        _create: function() {
                                                                                                                if ( !this.options.enhanced ) {
                                                                                                                    this._enhance();
                                                                                                                } else {
                                                                                                                    $.extend( this, {
                                                                                                    Severity: Minor
                                                                                                    Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

                                                                                                      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" ),
                                                                                                      Severity: Minor
                                                                                                      Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                            _create: function() {
                                                                                                                var that = this,
                                                                                                                    options = this.options;
                                                                                                        
                                                                                                                this.running = false;
                                                                                                        Severity: Minor
                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                  _loadSuccess: function( absUrl, triggerData, settings, deferred ) {
                                                                                                                      var fileUrl = this._createFileUrl( absUrl );
                                                                                                          
                                                                                                                      return $.proxy(function( html, textStatus, xhr ) {
                                                                                                                          //pre-parse html to check for a data-url,
                                                                                                          Severity: Minor
                                                                                                          Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                _addToggles: function( menu, keep ) {
                                                                                                                    var inputs,
                                                                                                                        checkboxIndex = 0,
                                                                                                                        opts = this.options,
                                                                                                                        container = menu.controlgroup( "container" );
                                                                                                            Severity: Minor
                                                                                                            Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                  _bindPageEvents: function() {
                                                                                                                      var self = this;
                                                                                                              
                                                                                                                      this.document
                                                                                                                          // Close the panel if another panel on the page opens
                                                                                                              Severity: Minor
                                                                                                              Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                _openPanel = function() {
                                                                                                                                    self._off( self.document , "panelclose" );
                                                                                                                                    self._page().jqmData( "panel", "open" );
                                                                                                                
                                                                                                                                    if ( $.support.cssTransform3d && !!o.animate && o.display !== "overlay" ) {
                                                                                                                Severity: Minor
                                                                                                                Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                              context.start = function( event ) {
                                                                                                                  
                                                                                                                                  // Bail if we're already working on a swipe event
                                                                                                                                  if ( $.event.special.swipe.eventInProgress ) {
                                                                                                                                      return;
                                                                                                                  Severity: Minor
                                                                                                                  Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                        _setOptions: function( options ) {
                                                                                                                            var callRefresh, returnValue,
                                                                                                                                elem = this.element;
                                                                                                                    
                                                                                                                            // Must have one of horizontal or vertical
                                                                                                                    Severity: Minor
                                                                                                                    Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                          refresh: function( force ) {
                                                                                                                              var self, indices;
                                                                                                                      
                                                                                                                              if ( this.options.nativeMenu ) {
                                                                                                                                  return this._super( force );
                                                                                                                      Severity: Minor
                                                                                                                      Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                        function createVirtualEvent( event, eventType ) {
                                                                                                                        
                                                                                                                            var t = event.type,
                                                                                                                                oe, props, ne, prop, ct, touch, i, j, len;
                                                                                                                        
                                                                                                                        
                                                                                                                        Severity: Minor
                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                              _setInput: function( selector ) {
                                                                                                                                  var opts = this.options,
                                                                                                                                      updatePlaceholder = true,
                                                                                                                                      textinputOpts = {};
                                                                                                                          
                                                                                                                          
                                                                                                                          Severity: Minor
                                                                                                                          Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                option: function( key, value ) {
                                                                                                                                    var options = key,
                                                                                                                                        parts,
                                                                                                                                        curOption,
                                                                                                                                        i;
                                                                                                                            Severity: Minor
                                                                                                                            Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                  _setOptions: function( options ) {
                                                                                                                                      var outer = this.widget();
                                                                                                                              
                                                                                                                                      if ( options.theme !== undefined ) {
                                                                                                                                          outer
                                                                                                                              Severity: Minor
                                                                                                                              Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                    _decideFormat: function() {
                                                                                                                                        var self = this,
                                                                                                                                            $window = this.window,
                                                                                                                                            selfListParent = self.list.parent(),
                                                                                                                                            menuHeight = selfListParent.outerHeight(),
                                                                                                                                Severity: Minor
                                                                                                                                Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                  $.fn.buttonMarkup = function( options, overwriteClasses ) {
                                                                                                                                      var idx, data, el, retrievedOptions, optionKey,
                                                                                                                                          defaults = $.fn.buttonMarkup.defaults;
                                                                                                                                  
                                                                                                                                      for ( idx = 0 ; idx < this.length ; idx++ ) {
                                                                                                                                  Severity: Minor
                                                                                                                                  Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                            _updateHeight: function() {
                                                                                                                                                var paddingTop, paddingBottom, paddingHeight, scrollHeight, clientHeight,
                                                                                                                                                    borderTop, borderBottom, borderHeight, height,
                                                                                                                                                    scrollTop = this.window.scrollTop();
                                                                                                                                                this.keyupTimeout = 0;
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                          _create: function() {
                                                                                                                                              var elem = this.element,
                                                                                                                                                  ui = {
                                                                                                                                                      accordion: elem
                                                                                                                                                          .closest( ":jqmData(role='collapsible-set')," +
                                                                                                                                      Severity: Minor
                                                                                                                                      Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                            _enhance: function( theElement, myId ) {
                                                                                                                                                var currentOptions = this.options,
                                                                                                                                                    wrapperClass = currentOptions.wrapperClass,
                                                                                                                                                    ui = {
                                                                                                                                                        screen: $( "<div class='ui-screen-hidden ui-popup-screen " +
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

                                                                                                                                          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 );
                                                                                                                                          
                                                                                                                                          
                                                                                                                                          Severity: Minor
                                                                                                                                          Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

                                                                                                                                            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 );
                                                                                                                                            
                                                                                                                                            
                                                                                                                                            Severity: Minor
                                                                                                                                            Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

                                                                                                                                              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 = uuid++;
                                                                                                                                                      this.eventNamespace = "." + this.widgetName + this.uuid;
                                                                                                                                              Severity: Minor
                                                                                                                                              Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                                    $.fn.animationComplete = function( callback, type, fallbackTime ) {
                                                                                                                                                        var timer, duration,
                                                                                                                                                            that = this,
                                                                                                                                                            eventBinding = function() {
                                                                                                                                                
                                                                                                                                                
                                                                                                                                                Severity: Minor
                                                                                                                                                Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                                          _bindToggleHandlers: function() {
                                                                                                                                                              var self = this,
                                                                                                                                                                  o = self.options,
                                                                                                                                                                  delayShow, delayHide,
                                                                                                                                                                  isVisible = true,
                                                                                                                                                  Severity: Minor
                                                                                                                                                  Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                                        _create: function() {
                                                                                                                                                            var elem = this.element,
                                                                                                                                                                opts = this.options,
                                                                                                                                                                keepNative = $.mobile.page.prototype.keepNativeSelector();
                                                                                                                                                    
                                                                                                                                                    
                                                                                                                                                    Severity: Minor
                                                                                                                                                    Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                                              go: function( url, data, noEvents ) {
                                                                                                                                                                  var state, href, hash, popstateEvent,
                                                                                                                                                                      isPopStateEvent = $.event.special.navigate.isPushStateEnabled();
                                                                                                                                                      
                                                                                                                                                                  // Get the url as it would look squashed on to the current resolution url
                                                                                                                                                      Severity: Minor
                                                                                                                                                      Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                                                _updateBackButton: function() {
                                                                                                                                                                    var backButton,
                                                                                                                                                                        options = this.options,
                                                                                                                                                                        theme = options.backBtnTheme || options.theme;
                                                                                                                                                        
                                                                                                                                                        
                                                                                                                                                        Severity: Minor
                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

                                                                                                                                                          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" ) {
                                                                                                                                                          Severity: Minor
                                                                                                                                                          Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                                                var compensateToolbars = function( page, desiredHeight ) {
                                                                                                                                                                    var pageParent = page.parent(),
                                                                                                                                                                        toolbarsAffectingHeight = [],
                                                                                                                                                            
                                                                                                                                                                        // We use this function to filter fixed toolbars with option updatePagePadding set to
                                                                                                                                                            Severity: Minor
                                                                                                                                                            Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                                                  _setOptions: function( options ) {
                                                                                                                                                                      var label = this.label,
                                                                                                                                                                          currentOptions = this.options,
                                                                                                                                                                          outer = this.widget(),
                                                                                                                                                                          hasIcon = this._hasIcon();
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                                                function optionsToClasses( options, existingClasses ) {
                                                                                                                                                                    var classes = existingClasses ? existingClasses : [];
                                                                                                                                                                
                                                                                                                                                                    // Add classes to the array - first ui-btn
                                                                                                                                                                    classes.push( "ui-btn" );
                                                                                                                                                                Severity: Minor
                                                                                                                                                                Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

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

                                                                                                                                                                              makePathAbsolute: function( relPath, absPath ) {
                                                                                                                                                                                  var absStack,
                                                                                                                                                                                      relStack,
                                                                                                                                                                                      i, d;
                                                                                                                                                                  
                                                                                                                                                                  
                                                                                                                                                                  Severity: Minor
                                                                                                                                                                  Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

                                                                                                                                                                    Consider simplifying this complex logical expression.
                                                                                                                                                                    Open

                                                                                                                                                                                if ( o.trackPersistentToolbars ) {
                                                                                                                                                                                    thisFooter = $( ".ui-footer-fixed:jqmData(id)", this.page );
                                                                                                                                                                                    thisHeader = $( ".ui-header-fixed:jqmData(id)", this.page );
                                                                                                                                                                                    nextFooter = thisFooter.length && ui.nextPage && $( ".ui-footer-fixed:jqmData(id='" + thisFooter.jqmData( "id" ) + "')", ui.nextPage ) || $();
                                                                                                                                                                                    nextHeader = thisHeader.length && ui.nextPage && $( ".ui-header-fixed:jqmData(id='" + thisHeader.jqmData( "id" ) + "')", ui.nextPage ) || $();
                                                                                                                                                                    Severity: Major
                                                                                                                                                                    Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

                                                                                                                                                                      Consider simplifying this complex logical expression.
                                                                                                                                                                      Open

                                                                                                                                                                                  if ( this.options.addBackBtn &&
                                                                                                                                                                      
                                                                                                                                                                                          // This must also be a header toolbar
                                                                                                                                                                                          this.role === "header" &&
                                                                                                                                                                      
                                                                                                                                                                      
                                                                                                                                                                      Severity: Major
                                                                                                                                                                      Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

                                                                                                                                                                        Consider simplifying this complex logical expression.
                                                                                                                                                                        Open

                                                                                                                                                                                if ( !window.orientation && ( x > 7 || ( ( z > 6 && y < 8 || z < 8 && y > 6 ) && x > 5 ) ) ) {
                                                                                                                                                                                        if ( zoom.enabled ) {
                                                                                                                                                                                            zoom.disable();
                                                                                                                                                                                        }
                                                                                                                                                                                }    else if ( !zoom.enabled ) {
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 1 hr to fix

                                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                                          Open

                                                                                                                                                                                              if ( ( ele === target && Math.abs( o.x - x ) < threshold && Math.abs( o.y - y ) < threshold ) ||
                                                                                                                                                                                                          $.data( ele, touchTargetPropertyName ) === o.touchID ) {
                                                                                                                                                                                                  // XXX: We may want to consider removing matches from the block list
                                                                                                                                                                                                  //      instead of waiting for the reset timer to fire.
                                                                                                                                                                                                  e.preventDefault();
                                                                                                                                                                          Severity: Major
                                                                                                                                                                          Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 45 mins to fix

                                                                                                                                                                            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 ||
                                                                                                                                                                            Severity: Major
                                                                                                                                                                            Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 40 mins to fix

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

                                                                                                                                                                                  _tryAnArrow: function( p, dir, desired, s, best ) {
                                                                                                                                                                              Severity: Minor
                                                                                                                                                                              Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 35 mins to fix

                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                Open

                                                                                                                                                                                                return;
                                                                                                                                                                                Severity: Major
                                                                                                                                                                                Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 30 mins to fix

                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                  Open

                                                                                                                                                                                              return deferred.promise();
                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                  Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 30 mins to fix

                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                    Open

                                                                                                                                                                                                    return;
                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                    Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 30 mins to fix

                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                      Open

                                                                                                                                                                                                          return;
                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                      Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js - About 30 mins to fix

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

                                                                                                                                                                                            _setOptions: function( options ) {
                                                                                                                                                                                                var closeButtonLocation, closeButtonText,
                                                                                                                                                                                                    currentOpts = this.options;
                                                                                                                                                                                        
                                                                                                                                                                                                if ( options.corners !== undefined ) {
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 day to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 6743..6772

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 231.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                            _setOptions: function( options ) {
                                                                                                                                                                                                var closeButtonLocation, closeButtonText,
                                                                                                                                                                                                    currentOpts = this.options;
                                                                                                                                                                                        
                                                                                                                                                                                                if ( options.corners !== undefined ) {
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 day to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 6594..6623

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 231.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                            _hoverable: function( element ) {
                                                                                                                                                                                                this.hoverable = this.hoverable.add( element );
                                                                                                                                                                                                this._on( element, {
                                                                                                                                                                                                    mouseenter: function( event ) {
                                                                                                                                                                                                        $( event.currentTarget ).addClass( "ui-state-hover" );
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 1183..1193

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 107.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                            _focusable: function( element ) {
                                                                                                                                                                                                this.focusable = this.focusable.add( element );
                                                                                                                                                                                                this._on( element, {
                                                                                                                                                                                                    focusin: function( event ) {
                                                                                                                                                                                                        $( event.currentTarget ).addClass( "ui-state-focus" );
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 1171..1181

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 107.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                            _right: function() {
                                                                                                                                                                                                this.flipswitch.addClass( "ui-flipswitch-active" );
                                                                                                                                                                                                if ( this.type === "SELECT" ) {
                                                                                                                                                                                                    this.element.get( 0 ).selectedIndex = 1;
                                                                                                                                                                                                } else {
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 9259..9267

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 98.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                            _left: function() {
                                                                                                                                                                                                this.flipswitch.removeClass( "ui-flipswitch-active" );
                                                                                                                                                                                                if ( this.type === "SELECT" ) {
                                                                                                                                                                                                    this.element.get( 0 ).selectedIndex = 0;
                                                                                                                                                                                                } else {
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 9269..9277

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 98.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                            if ( $.support.cssTransform3d && !!o.animate && o.display !== "overlay" ) {
                                                                                                                                                                                                                self._wrapper.addClass( o.classes.animate );
                                                                                                                                                                                                                self._fixedToolbars().addClass( o.classes.animate );
                                                                                                                                                                                                            }
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 13464..13467

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 88.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                            if ( $.support.cssTransform3d && !!o.animate && o.display !== "overlay" ) {
                                                                                                                                                                                                                self._wrapper.removeClass( o.classes.animate );
                                                                                                                                                                                                                self._fixedToolbars().removeClass( o.classes.animate );
                                                                                                                                                                                                            }
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 13353..13356

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 88.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                            if ( o.theme && o.display !== "overlay" ) {
                                                                                                                                                                                                                self._page().parent()
                                                                                                                                                                                                                    .addClass( o.classes.pageContainer + "-themed " + o.classes.pageContainer + "-" + o.theme );
                                                                                                                                                                                                            }
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 13452..13454

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 84.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                            if ( o.theme && o.display !== "overlay" ) {
                                                                                                                                                                                                                self._page().parent().removeClass( o.classes.pageContainer + "-themed " + o.classes.pageContainer + "-" + o.theme );
                                                                                                                                                                                                            }
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 13365..13368

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 84.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                        hasFixed = $(  "body>.ui-" + this.role + "-fixed" )
                                                                                                                                                                                                                    .add( page.find( ".ui-" + this.options.role + "-fixed" ) )
                                                                                                                                                                                                                    .not( this.element ).length > 0;
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 12709..12711

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 75.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                        hasFullscreen = $(  "body>.ui-" + this.role + "-fixed" )
                                                                                                                                                                                                                    .add( page.find( ".ui-" + this.options.role + "-fullscreen" ) )
                                                                                                                                                                                                                    .not( this.element ).length > 0;
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 12706..12708

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 75.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                            $.addDependents = function( elem, newDependents ) {
                                                                                                                                                                                                var $elem = $( elem ),
                                                                                                                                                                                                    dependents = $elem.jqmData( "dependents" ) || $();
                                                                                                                                                                                        
                                                                                                                                                                                                $elem.jqmData( "dependents", $( dependents ).add( newDependents ) );
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 634..639

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 72.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                            $.addDependents = function( nativeElement, newDependents ) {
                                                                                                                                                                                                var element = $( nativeElement ),
                                                                                                                                                                                                    dependents = element.jqmData( "dependents" ) || $();
                                                                                                                                                                                        
                                                                                                                                                                                                element.jqmData( "dependents", $( dependents ).add( newDependents ) );
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 529..534

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 72.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
                                                                                                                                                                                                    this._activate( this._focusNextTab( this.options.active + 1, true ) );
                                                                                                                                                                                                    return true;
                                                                                                                                                                                                }
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 14621..14624

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 70.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
                                                                                                                                                                                                    this._activate( this._focusNextTab( this.options.active - 1, false ) );
                                                                                                                                                                                                    return true;
                                                                                                                                                                                                }
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 14625..14628

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 70.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                            if ( !immediate && $.support.cssTransform3d && !!o.animate ) {
                                                                                                                                                                                                                ( self._wrapper || self.element )
                                                                                                                                                                                                                    .animationComplete( complete, "transition" );
                                                                                                                                                                                                            } else {
                                                                                                                                                                                                                setTimeout( complete, 0 );
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 13438..13443

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 69.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                            if ( !immediate && $.support.cssTransform3d && !!o.animate ) {
                                                                                                                                                                                                                ( self._wrapper || self.element )
                                                                                                                                                                                                                    .animationComplete( complete, "transition" );
                                                                                                                                                                                                            } else {
                                                                                                                                                                                                                setTimeout( complete, 0 );
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 13358..13363

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 69.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                            _fixPanel: function() {
                                                                                                                                                                                                if ( !!this.options.positionFixed && $.support.fixedPosition ) {
                                                                                                                                                                                                    this.element.addClass( this.options.classes.panelFixed );
                                                                                                                                                                                                }
                                                                                                                                                                                            },
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 13234..13238

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 68.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    "r": { fst: "x", snd: "y", prop: "top", dimKey: "cy", oDimKey: "cx", offsetFactor: -1, tipOffset: state.arHalf.cx + state.contentBox.cx, arrowOffsetFactor: 1 },
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 12965..12965

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 68.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    "b": { fst: "y", snd: "x", prop: "left", dimKey: "cx", oDimKey: "cy", offsetFactor: -1, tipOffset: state.arHalf.cy + state.contentBox.cy, arrowOffsetFactor: 1 },
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 12964..12964

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 68.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                            _unfixPanel: function() {
                                                                                                                                                                                                if ( !!this.options.positionFixed && $.support.fixedPosition ) {
                                                                                                                                                                                                    this.element.removeClass( this.options.classes.panelFixed );
                                                                                                                                                                                                }
                                                                                                                                                                                            },
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 13240..13244

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 68.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    var data = event.originalEvent.touches ?
                                                                                                                                                                                                            event.originalEvent.touches[ 0 ] : event,
                                                                                                                                                                                                        location = $.event.special.swipe.getLocation( data );
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 3995..3997

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 58.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    var data = event.originalEvent.touches ?
                                                                                                                                                                                                            event.originalEvent.touches[ 0 ] : event,
                                                                                                                                                                                                        location = $.event.special.swipe.getLocation( data );
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 4006..4008

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 58.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    "l": { fst: "x", snd: "y", prop: "top", dimKey: "cy", oDimKey: "cx", offsetFactor: 1, tipOffset:  -state.arHalf.cx, arrowOffsetFactor: 0 },
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 12966..12966

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 56.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    if ( this.menuType === "overlay" ) {
                                                                                                                                                                                                        this.button.attr( "href", "#" + this.popupId ).attr( "data-" + ( $.mobile.ns || "" ) + "rel", "popup" );
                                                                                                                                                                                                    } else {
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 11294..11296

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 56.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                            _unenhance: function() {
                                                                                                                                                                                                var ar = this._ui.arrow;
                                                                                                                                                                                        
                                                                                                                                                                                                if ( ar ) {
                                                                                                                                                                                                    ar.arEls.remove();
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 13041..13049

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 56.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    } else {
                                                                                                                                                                                                        this.button.attr( "href", "#" + this.dialogId ).attr( "data-" + ( $.mobile.ns || "" ) + "rel", "dialog" );
                                                                                                                                                                                                    }
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 11292..11294

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 56.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                            _destroy: function() {
                                                                                                                                                                                                var ar = this._ui.arrow;
                                                                                                                                                                                        
                                                                                                                                                                                                if ( ar ) {
                                                                                                                                                                                                    ar.arEls.remove();
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 12874..12882

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 56.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    "t": { fst: "y", snd: "x", prop: "left", dimKey: "cx", oDimKey: "cy", offsetFactor: 1, tipOffset: -state.arHalf.cy, arrowOffsetFactor: 0 }
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 12963..12963

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 56.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                self.label.bind( "click focus", function() {
                                                                                                                                                                                                    if ( self.options.preventFocusZoom ) {
                                                                                                                                                                                                            $.mobile.zoom.disable( true );
                                                                                                                                                                                                    }
                                                                                                                                                                                                });
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 10144..10148
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 10156..10160

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 55.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                self.select.bind( "focus", function() {
                                                                                                                                                                                                    if ( self.options.preventFocusZoom ) {
                                                                                                                                                                                                            $.mobile.zoom.disable( true );
                                                                                                                                                                                                    }
                                                                                                                                                                                                });
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 10139..10143
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 10156..10160

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 55.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                        nextFooter = thisFooter.length && ui.nextPage && $( ".ui-footer-fixed:jqmData(id='" + thisFooter.jqmData( "id" ) + "')", ui.nextPage ) || $();
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 12560..12560

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 55.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                        nextHeader = thisHeader.length && ui.nextPage && $( ".ui-header-fixed:jqmData(id='" + thisHeader.jqmData( "id" ) + "')", ui.nextPage ) || $();
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 12559..12559

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 55.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                self.select.bind( "blur", function() {
                                                                                                                                                                                                    if ( self.options.preventFocusZoom ) {
                                                                                                                                                                                                        $.mobile.zoom.enable( true );
                                                                                                                                                                                                    }
                                                                                                                                                                                                });
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 10139..10143
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 10144..10148

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 55.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                        present: function( historyEntry, direction ) {
                                                                                                                                                                                                            // make sure to create a new object to pass down as the navigate event data
                                                                                                                                                                                                            event.hashchangeState = $.extend({}, historyEntry);
                                                                                                                                                                                                            event.hashchangeState.direction = direction;
                                                                                                                                                                                                        },
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 3131..3135

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 53.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                        present: function( historyEntry, direction ) {
                                                                                                                                                                                                            // make sure to create a new object to pass down as the navigate event data
                                                                                                                                                                                                            event.historyState = $.extend({}, historyEntry);
                                                                                                                                                                                                            event.historyState.direction = direction;
                                                                                                                                                                                                        }
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 3172..3176

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 53.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                ( ( platform.indexOf( "iPhone" ) > -1 || platform.indexOf( "iPad" ) > -1  || platform.indexOf( "iPod" ) > -1 ) && wkversion && wkversion < 534 ) ||
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 12748..12748

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 51.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    if ( platform.indexOf( "iPhone" ) > -1 || platform.indexOf( "iPad" ) > -1  || platform.indexOf( "iPod" ) > -1 ) {
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 2142..2142

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 51.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                        max = parseInt( $.data( this._inputLast.get(0), "mobile-slider" ).handle.get(0).style.left, 10 ),
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 9625..9625

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 51.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    var min = parseInt( $.data( this._inputFirst.get(0), "mobile-slider" ).handle.get(0).style.left, 10 ),
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 9626..9626

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 51.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                if ( options.inset !== undefined ) {
                                                                                                                                                                                                    hasCorners = !!( options.inset && ( options.corners || this.options.corners ) );
                                                                                                                                                                                                }
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 7295..7297

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 50.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                if ( options.corners !== undefined ) {
                                                                                                                                                                                                    hasCorners = !!( options.corners && ( options.inset || this.options.inset ) );
                                                                                                                                                                                                }
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 7291..7293

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 50.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    _sliderWidgetFirst = $.data( _inputFirst.get( 0 ), "mobile-slider" ) ||
                                                                                                                                                                                                        $.data( _inputFirst.slider().get( 0 ), "mobile-slider" ),
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 9433..9434

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 50.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    _sliderWidgetLast = $.data( _inputLast.get(0), "mobile-slider" ) ||
                                                                                                                                                                                                        $.data( _inputLast.slider().get( 0 ), "mobile-slider" ),
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 9431..9432

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 50.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    if ( stop.time - start.time < $.event.special.swipe.durationThreshold &&
                                                                                                                                                                                                        Math.abs( start.coords[ 0 ] - stop.coords[ 0 ] ) > $.event.special.swipe.horizontalDistanceThreshold &&
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 4016..4018

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 50.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                            $.fn[ event_name ] = function( fn ) {
                                                                                                                                                                                                return fn ? this.bind( event_name, fn ) : this.trigger( event_name );
                                                                                                                                                                                            };
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 3832..3834

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 49.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                $.fn[ name ] = function( fn ) {
                                                                                                                                                                                                    return fn ? this.bind( name, fn ) : this.trigger( name );
                                                                                                                                                                                                };
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 4310..4312

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 49.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    if ( options.theme !== undefined && options.theme !== "none" ) {
                                                                                                                                                                                                        this.element.removeClass( "ui-overlay-" + this.options.theme )
                                                                                                                                                                                                            .addClass( "ui-overlay-" + options.theme );
                                                                                                                                                                                                    } else if ( options.theme !== undefined ) {
                                                                                                                                                                                                        this.element.removeClass( "ui-overlay-" + this.options.theme );
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 4513..4515

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 47.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                if ( o.theme !== undefined ) {
                                                                                                                                                                                                    this.element.removeClass( "ui-page-theme-" + this.options.theme ).addClass( "ui-page-theme-" + o.theme );
                                                                                                                                                                                                }
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 4599..4604

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 47.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                if ( $.fn.buttonMarkup ) {
                                                                                                                                                                                                    this.element
                                                                                                                                                                                                        .find( $.fn.buttonMarkup.initSelector )
                                                                                                                                                                                                        .not( keepNative )
                                                                                                                                                                                                        .buttonMarkup();
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 12098..12102

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 46.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    if ( $.mobile[ widgetName ] ) {
                                                                                                                                                                                                        this.element
                                                                                                                                                                                                            .find( $.mobile[ widgetName ].initSelector )
                                                                                                                                                                                                            .not( keepNative )[ widgetName ]();
                                                                                                                                                                                                    }
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 12090..12095

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 46.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                } else if ( btn ) {
                                                                                                                                                                                                    btn.removeClass( "ui-btn-left ui-btn-right" ).addClass( "ui-btn-" + location );
                                                                                                                                                                                                    if ( text ) {
                                                                                                                                                                                                        btn.text( text );
                                                                                                                                                                                                    }
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 6786..6801

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 45.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                _setTrackTheme: function( value ) {
                                                                                                                                                                                                    this._inputFirst.slider( "option", "trackTheme", value );
                                                                                                                                                                                                    this._inputLast.slider( "option", "trackTheme", value );
                                                                                                                                                                                                },
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 2 other locations - About 30 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 9635..9638
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 9651..9654

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 45.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                _setTheme: function( value ) {
                                                                                                                                                                                                    this._inputFirst.slider( "option", "theme", value );
                                                                                                                                                                                                    this._inputLast.slider( "option", "theme", value );
                                                                                                                                                                                                },
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 2 other locations - About 30 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 9640..9643
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 9651..9654

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 45.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                _setHighlight: function( value ) {
                                                                                                                                                                                                    this._inputFirst.slider( "option", "highlight", value );
                                                                                                                                                                                                    this._inputLast.slider( "option", "highlight", value );
                                                                                                                                                                                                },
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 2 other locations - About 30 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 9635..9638
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 9640..9643

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 45.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                } else if ( btn ) {
                                                                                                                                                                                                    btn.removeClass( "ui-btn-left ui-btn-right" ).addClass( "ui-btn-" + location );
                                                                                                                                                                                                    if ( text ) {
                                                                                                                                                                                                        btn.text( text );
                                                                                                                                                                                                    }
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 6646..6660

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 45.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                            samePath = u.hrefNoHash === this.documentUrl.hrefNoHash ||
                                                                                                                                                                                                                ( this.documentBaseDiffers &&
                                                                                                                                                                                                                    u.hrefNoHash === this.documentBase.hrefNoHash ),
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 2629..2629

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 45.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    screen
                                                                                                                                                                                                        .removeClass( this._themeClassFromOption( "ui-overlay-", currentOptions.overlayTheme ) )
                                                                                                                                                                                                        .addClass( this._themeClassFromOption( "ui-overlay-", newOptions.overlayTheme ) );
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 10600..10602

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 45.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                            return ( !this.isPath(u.hash) && u.hash && ( u.hrefNoHash === this.documentUrl.hrefNoHash || ( this.documentBaseDiffers && u.hrefNoHash === this.documentBase.hrefNoHash ) ) );
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 2735..2737

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 45.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

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

                                                                                                                                                                                                    theElement
                                                                                                                                                                                                        .removeClass( this._themeClassFromOption( "ui-body-", currentOptions.theme ) )
                                                                                                                                                                                                        .addClass( this._themeClassFromOption( "ui-body-", newOptions.theme ) );
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                        js/jquery.mobile-1.4.5/jquery.mobile-1.4.5.js on lines 10606..10608

                                                                                                                                                                                        Duplicated Code

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

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

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

                                                                                                                                                                                        Tuning

                                                                                                                                                                                        This issue has a mass of 45.

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

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

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

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

                                                                                                                                                                                        Refactorings

                                                                                                                                                                                        Further Reading

                                                                                                                                                                                        There are no issues that match your filters.

                                                                                                                                                                                        Category
                                                                                                                                                                                        Status