ricarthlima/eo-project-es

View on GitHub
app/assets/javascripts/application.js

Summary

Maintainability
F
3 wks
Test Coverage

Function Tooltip has 515 lines of code (exceeds 25 allowed). Consider refactoring.
Wontfix

  var Tooltip = function ($$$1) {
    /**
     * ------------------------------------------------------------------------
     * Constants
     * ------------------------------------------------------------------------
Severity: Major
Found in app/assets/javascripts/application.js - About 2 days to fix

    Function Tooltip has 432 lines of code (exceeds 25 allowed). Consider refactoring.
    Wontfix

        function () {
          function Tooltip(element, config) {
            /**
             * Check for Popper dependency
             * Popper - https://popper.js.org
    Severity: Major
    Found in app/assets/javascripts/application.js - About 2 days to fix

      Function Modal has 414 lines of code (exceeds 25 allowed). Consider refactoring.
      Wontfix

        var Modal = function ($$$1) {
          /**
           * ------------------------------------------------------------------------
           * Constants
           * ------------------------------------------------------------------------
      Severity: Major
      Found in app/assets/javascripts/application.js - About 2 days to fix

        Function Carousel has 368 lines of code (exceeds 25 allowed). Consider refactoring.
        Wontfix

          var Carousel = function ($$$1) {
            /**
             * ------------------------------------------------------------------------
             * Constants
             * ------------------------------------------------------------------------
        Severity: Major
        Found in app/assets/javascripts/application.js - About 1 day to fix

          Function Dropdown has 335 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            var Dropdown = function ($$$1) {
              /**
               * ------------------------------------------------------------------------
               * Constants
               * ------------------------------------------------------------------------
          Severity: Major
          Found in app/assets/javascripts/application.js - About 1 day to fix

            Function Modal has 335 lines of code (exceeds 25 allowed). Consider refactoring.
            Wontfix

                function () {
                  function Modal(element, config) {
                    this._config = this._getConfig(config);
                    this._element = element;
                    this._dialog = element.querySelector(Selector.DIALOG);
            Severity: Major
            Found in app/assets/javascripts/application.js - About 1 day to fix

              Function Carousel has 292 lines of code (exceeds 25 allowed). Consider refactoring.
              Wontfix

                  function () {
                    function Carousel(element, config) {
                      this._items = null;
                      this._interval = null;
                      this._activeElement = null;
              Severity: Major
              Found in app/assets/javascripts/application.js - About 1 day to fix

                Function Collapse has 262 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                  var Collapse = function ($$$1) {
                    /**
                     * ------------------------------------------------------------------------
                     * Constants
                     * ------------------------------------------------------------------------
                Severity: Major
                Found in app/assets/javascripts/application.js - About 1 day to fix

                  Function Dropdown has 254 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      function () {
                        function Dropdown(element, config) {
                          this._element = element;
                          this._popper = null;
                          this._config = this._getConfig(config);
                  Severity: Major
                  Found in app/assets/javascripts/application.js - About 1 day to fix

                    Function ScrollSpy has 220 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                      var ScrollSpy = function ($$$1) {
                        /**
                         * ------------------------------------------------------------------------
                         * Constants
                         * ------------------------------------------------------------------------
                    Severity: Major
                    Found in app/assets/javascripts/application.js - About 1 day to fix

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

                          function () {
                            function Collapse(element, config) {
                              this._isTransitioning = false;
                              this._element = element;
                              this._config = this._getConfig(config);
                      Severity: Major
                      Found in app/assets/javascripts/application.js - About 1 day to fix

                        Function Tab has 170 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                          var Tab = function ($$$1) {
                            /**
                             * ------------------------------------------------------------------------
                             * Constants
                             * ------------------------------------------------------------------------
                        Severity: Major
                        Found in app/assets/javascripts/application.js - About 6 hrs to fix

                          Function ScrollSpy has 161 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                              function () {
                                function ScrollSpy(element, config) {
                                  var _this = this;
                          
                                  this._element = element;
                          Severity: Major
                          Found in app/assets/javascripts/application.js - About 6 hrs to fix

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

                              var Popover = function ($$$1) {
                                /**
                                 * ------------------------------------------------------------------------
                                 * Constants
                                 * ------------------------------------------------------------------------
                            Severity: Major
                            Found in app/assets/javascripts/application.js - About 5 hrs to fix

                              Function Tab has 127 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                  function () {
                                    function Tab(element) {
                                      this._element = element;
                                    } // Getters
                              
                              
                              Severity: Major
                              Found in app/assets/javascripts/application.js - About 5 hrs to fix

                                Function Alert has 108 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                  var Alert = function ($$$1) {
                                    /**
                                     * ------------------------------------------------------------------------
                                     * Constants
                                     * ------------------------------------------------------------------------
                                Severity: Major
                                Found in app/assets/javascripts/application.js - About 4 hrs to fix

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

                                    var Button = function ($$$1) {
                                      /**
                                       * ------------------------------------------------------------------------
                                       * Constants
                                       * ------------------------------------------------------------------------
                                  Severity: Major
                                  Found in app/assets/javascripts/application.js - About 4 hrs to fix

                                    Function Util has 93 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                      var Util = function ($$$1) {
                                        /**
                                         * ------------------------------------------------------------------------
                                         * Private TransitionEnd Helpers
                                         * ------------------------------------------------------------------------
                                    Severity: Major
                                    Found in app/assets/javascripts/application.js - About 3 hrs to fix

                                      Function Popover has 91 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                          function (_Tooltip) {
                                            _inheritsLoose(Popover, _Tooltip);
                                      
                                            function Popover() {
                                              return _Tooltip.apply(this, arguments) || this;
                                      Severity: Major
                                      Found in app/assets/javascripts/application.js - About 3 hrs to fix

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

                                            function () {
                                              function Alert(element) {
                                                this._element = element;
                                              } // Getters
                                        
                                        
                                        Severity: Major
                                        Found in app/assets/javascripts/application.js - About 3 hrs to fix

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

                                                _proto.show = function show() {
                                                  var _this = this;
                                          
                                                  if ($$$1(this.element).css('display') === 'none') {
                                                    throw new Error('Please use show on visible elements');
                                          Severity: Major
                                          Found in app/assets/javascripts/application.js - About 3 hrs to fix

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

                                                  _proto._slide = function _slide(direction, element) {
                                                    var _this3 = this;
                                            
                                                    var activeElement = this._element.querySelector(Selector.ACTIVE_ITEM);
                                            
                                            
                                            Severity: Major
                                            Found in app/assets/javascripts/application.js - About 2 hrs to fix

                                              Function Button has 62 lines of code (exceeds 25 allowed). Consider refactoring.
                                              Open

                                                  function () {
                                                    function Button(element) {
                                                      this._element = element;
                                                    } // Getters
                                              
                                              
                                              Severity: Major
                                              Found in app/assets/javascripts/application.js - About 2 hrs to fix

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

                                                      _proto._showBackdrop = function _showBackdrop(callback) {
                                                        var _this8 = this;
                                                
                                                        var animate = $$$1(this._element).hasClass(ClassName.FADE) ? ClassName.FADE : '';
                                                
                                                
                                                Severity: Major
                                                Found in app/assets/javascripts/application.js - About 2 hrs to fix

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

                                                        _proto.show = function show() {
                                                          var _this = this;
                                                  
                                                          if (this._isTransitioning || $$$1(this._element).hasClass(ClassName.SHOW)) {
                                                            return;
                                                  Severity: Minor
                                                  Found in app/assets/javascripts/application.js - About 1 hr to fix

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

                                                          _proto.show = function show() {
                                                            var _this = this;
                                                    
                                                            if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $$$1(this._element).hasClass(ClassName.ACTIVE) || $$$1(this._element).hasClass(ClassName.DISABLED)) {
                                                              return;
                                                    Severity: Minor
                                                    Found in app/assets/javascripts/application.js - About 1 hr to fix

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

                                                            _proto.toggle = function toggle() {
                                                              if (this._element.disabled || $$$1(this._element).hasClass(ClassName.DISABLED)) {
                                                                return;
                                                              }
                                                      
                                                      
                                                      Severity: Minor
                                                      Found in app/assets/javascripts/application.js - About 1 hr to fix

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

                                                              _proto.hide = function hide(callback) {
                                                                var _this2 = this;
                                                        
                                                                var tip = this.getTipElement();
                                                                var hideEvent = $$$1.Event(this.constructor.Event.HIDE);
                                                        Severity: Minor
                                                        Found in app/assets/javascripts/application.js - About 1 hr to fix

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

                                                                Dropdown._clearMenus = function _clearMenus(event) {
                                                                  if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH || event.type === 'keyup' && event.which !== TAB_KEYCODE)) {
                                                                    return;
                                                                  }
                                                          
                                                          
                                                          Severity: Minor
                                                          Found in app/assets/javascripts/application.js - About 1 hr to fix

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

                                                                  _proto.show = function show(relatedTarget) {
                                                                    var _this = this;
                                                            
                                                                    if (this._isTransitioning || this._isShown) {
                                                                      return;
                                                            Severity: Minor
                                                            Found in app/assets/javascripts/application.js - About 1 hr to fix

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

                                                                    _proto.hide = function hide() {
                                                                      var _this2 = this;
                                                              
                                                                      if (this._isTransitioning || !$$$1(this._element).hasClass(ClassName.SHOW)) {
                                                                        return;
                                                              Severity: Minor
                                                              Found in app/assets/javascripts/application.js - About 1 hr to fix

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

                                                                      _proto.toggle = function toggle() {
                                                                        var triggerChangeEvent = true;
                                                                        var addAriaPressed = true;
                                                                        var rootElement = $$$1(this._element).closest(Selector.DATA_TOGGLE)[0];
                                                                
                                                                
                                                                Severity: Minor
                                                                Found in app/assets/javascripts/application.js - About 1 hr to fix

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

                                                                        Dropdown._dataApiKeydownHandler = function _dataApiKeydownHandler(event) {
                                                                          // If not input/textarea:
                                                                          //  - And not a key in REGEXP_KEYDOWN => not a dropdown command
                                                                          // If input/textarea:
                                                                          //  - If space key => not a dropdown command
                                                                  Severity: Minor
                                                                  Found in app/assets/javascripts/application.js - About 1 hr to fix

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

                                                                          _proto._showElement = function _showElement(relatedTarget) {
                                                                            var _this3 = this;
                                                                    
                                                                            var transition = $$$1(this._element).hasClass(ClassName.FADE);
                                                                    
                                                                    
                                                                    Severity: Minor
                                                                    Found in app/assets/javascripts/application.js - About 1 hr to fix

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

                                                                            _proto.hide = function hide(event) {
                                                                              var _this2 = this;
                                                                      
                                                                              if (event) {
                                                                                event.preventDefault();
                                                                      Severity: Minor
                                                                      Found in app/assets/javascripts/application.js - About 1 hr to fix

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

                                                                              _proto.refresh = function refresh() {
                                                                                var _this2 = this;
                                                                        
                                                                                var autoMethod = this._scrollElement === this._scrollElement.window ? OffsetMethod.OFFSET : OffsetMethod.POSITION;
                                                                                var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method;
                                                                        Severity: Minor
                                                                        Found in app/assets/javascripts/application.js - About 1 hr to fix

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

                                                                                _proto._getPopperConfig = function _getPopperConfig() {
                                                                                  var _this2 = this;
                                                                          
                                                                                  var offsetConf = {};
                                                                          
                                                                          
                                                                          Severity: Minor
                                                                          Found in app/assets/javascripts/application.js - About 1 hr to fix

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

                                                                                  _proto._setListeners = function _setListeners() {
                                                                                    var _this3 = this;
                                                                            
                                                                                    var triggers = this.config.trigger.split(' ');
                                                                                    triggers.forEach(function (trigger) {
                                                                            Severity: Minor
                                                                            Found in app/assets/javascripts/application.js - About 1 hr to fix

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

                                                                                    _proto._transitionComplete = function _transitionComplete(element, active, callback) {
                                                                                      if (active) {
                                                                                        $$$1(active).removeClass(ClassName.SHOW + " " + ClassName.ACTIVE);
                                                                                        var dropdownChild = $$$1(active.parentNode).find(Selector.DROPDOWN_ACTIVE_CHILD)[0];
                                                                              
                                                                              
                                                                              Severity: Minor
                                                                              Found in app/assets/javascripts/application.js - About 1 hr to fix

                                                                                Avoid deeply nested control flow statements.
                                                                                Open

                                                                                                if (activeElement) {
                                                                                                  $$$1(activeElement).removeClass(ClassName.ACTIVE);
                                                                                                }
                                                                                Severity: Major
                                                                                Found in app/assets/javascripts/application.js - About 45 mins to fix

                                                                                  Consider simplifying this complex logical expression.
                                                                                  Open

                                                                                            if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) && $$$1.contains(parent, event.target)) {
                                                                                              continue;
                                                                                            }
                                                                                  Severity: Major
                                                                                  Found in app/assets/javascripts/application.js - About 40 mins to fix

                                                                                    Consider simplifying this complex logical expression.
                                                                                    Open

                                                                                        if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >= maxMajor) {
                                                                                          throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0');
                                                                                        }
                                                                                    Severity: Major
                                                                                    Found in app/assets/javascripts/application.js - About 40 mins to fix

                                                                                      Consider simplifying this complex logical expression.
                                                                                      Open

                                                                                              if (!isActive && (event.which !== ESCAPE_KEYCODE || event.which !== SPACE_KEYCODE) || isActive && (event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE)) {
                                                                                                if (event.which === ESCAPE_KEYCODE) {
                                                                                                  var toggle = parent.querySelector(Selector.DATA_TOGGLE);
                                                                                                  $$$1(toggle).trigger('focus');
                                                                                                }
                                                                                      Severity: Major
                                                                                      Found in app/assets/javascripts/application.js - About 40 mins to fix

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

                                                                                                  $$$1(fixedContent).each(function (index, element) {
                                                                                                    var actualPadding = element.style.paddingRight;
                                                                                                    var calculatedPadding = $$$1(element).css('padding-right');
                                                                                                    $$$1(element).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + _this9._scrollbarWidth + "px");
                                                                                                  }); // Adjust sticky content margin
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 3 hrs to fix
                                                                                        app/assets/javascripts/application.js on lines 2356..2360

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 101.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                                  $$$1(stickyContent).each(function (index, element) {
                                                                                                    var actualMargin = element.style.marginRight;
                                                                                                    var calculatedMargin = $$$1(element).css('margin-right');
                                                                                                    $$$1(element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) - _this9._scrollbarWidth + "px");
                                                                                                  }); // Adjust body padding
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 3 hrs to fix
                                                                                        app/assets/javascripts/application.js on lines 2350..2354

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 101.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                                  if ($$$1(this._element).hasClass(ClassName.FADE)) {
                                                                                                    var _backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop);
                                                                                        
                                                                                                    $$$1(this._backdrop).one(Util.TRANSITION_END, callbackRemove).emulateTransitionEnd(_backdropTransitionDuration);
                                                                                                  } else {
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 2 hrs to fix
                                                                                        app/assets/javascripts/application.js on lines 2774..2779

                                                                                        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 ($$$1(this.tip).hasClass(ClassName.FADE)) {
                                                                                                    var transitionDuration = Util.getTransitionDurationFromElement(this.tip);
                                                                                                    $$$1(this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
                                                                                                  } else {
                                                                                                    complete();
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 2 hrs to fix
                                                                                        app/assets/javascripts/application.js on lines 2302..2308

                                                                                        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

                                                                                                  } else if (Util.isElement(this._config.reference)) {
                                                                                                    referenceElement = this._config.reference; // Check if it's jQuery element
                                                                                        
                                                                                                    if (typeof this._config.reference.jquery !== 'undefined') {
                                                                                                      referenceElement = this._config.reference[0];
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 1320..1328

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 67.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                                if (Util.isElement(this._config.parent)) {
                                                                                                  parent = this._config.parent; // It's a jQuery object
                                                                                        
                                                                                                  if (typeof this._config.parent.jquery !== 'undefined') {
                                                                                                    parent = this._config.parent[0];
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 1581..1587

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 67.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                                context._timeout = setTimeout(function () {
                                                                                                  if (context._hoverState === HoverState.SHOW) {
                                                                                                    context.show();
                                                                                                  }
                                                                                                }, context.config.delay.show);
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 2995..2999

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 62.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                                context._timeout = setTimeout(function () {
                                                                                                  if (context._hoverState === HoverState.OUT) {
                                                                                                    context.hide();
                                                                                                  }
                                                                                                }, context.config.delay.hide);
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 2963..2967

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 62.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                              _proto.getTipElement = function getTipElement() {
                                                                                                this.tip = this.tip || $$$1(this.config.template)[0];
                                                                                                return this.tip;
                                                                                              };
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 3243..3246

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

                                                                                        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

                                                                                              _proto.getTipElement = function getTipElement() {
                                                                                                this.tip = this.tip || $$$1(this.config.template)[0];
                                                                                                return this.tip;
                                                                                              };
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 2851..2854

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

                                                                                        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 Event = {
                                                                                              SHOW: "show" + EVENT_KEY,
                                                                                              SHOWN: "shown" + EVENT_KEY,
                                                                                              HIDE: "hide" + EVENT_KEY,
                                                                                              HIDDEN: "hidden" + EVENT_KEY,
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 3696..3702

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 57.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                            var Event = {
                                                                                              HIDE: "hide" + EVENT_KEY,
                                                                                              HIDDEN: "hidden" + EVENT_KEY,
                                                                                              SHOW: "show" + EVENT_KEY,
                                                                                              SHOWN: "shown" + EVENT_KEY,
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 1094..1100

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 57.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                                  if (!context) {
                                                                                                    context = new this.constructor(event.currentTarget, this._getDelegateConfig());
                                                                                                    $$$1(event.currentTarget).data(dataKey, context);
                                                                                                  }
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 2 other locations - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 2941..2944
                                                                                        app/assets/javascripts/application.js on lines 2974..2977

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 56.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                                if (!context) {
                                                                                                  context = new this.constructor(event.currentTarget, this._getDelegateConfig());
                                                                                                  $$$1(event.currentTarget).data(dataKey, context);
                                                                                                }
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 2 other locations - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 2638..2641
                                                                                        app/assets/javascripts/application.js on lines 2941..2944

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 56.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                                if (!context) {
                                                                                                  context = new this.constructor(event.currentTarget, this._getDelegateConfig());
                                                                                                  $$$1(event.currentTarget).data(dataKey, context);
                                                                                                }
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 2 other locations - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 2638..2641
                                                                                        app/assets/javascripts/application.js on lines 2974..2977

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 56.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                                  if (typeof config === 'string') {
                                                                                                    if (typeof data[config] === 'undefined') {
                                                                                                      throw new TypeError("No method named \"" + config + "\"");
                                                                                                    }
                                                                                        
                                                                                        
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 5 other locations - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 1740..1746
                                                                                        app/assets/javascripts/application.js on lines 3097..3103
                                                                                        app/assets/javascripts/application.js on lines 3293..3299
                                                                                        app/assets/javascripts/application.js on lines 3619..3625
                                                                                        app/assets/javascripts/application.js on lines 3878..3884

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 55.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                                  if (typeof config === 'string') {
                                                                                                    if (typeof data[config] === 'undefined') {
                                                                                                      throw new TypeError("No method named \"" + config + "\"");
                                                                                                    }
                                                                                        
                                                                                        
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 5 other locations - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 1370..1376
                                                                                        app/assets/javascripts/application.js on lines 1740..1746
                                                                                        app/assets/javascripts/application.js on lines 3293..3299
                                                                                        app/assets/javascripts/application.js on lines 3619..3625
                                                                                        app/assets/javascripts/application.js on lines 3878..3884

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 55.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                                  if (typeof config === 'string') {
                                                                                                    if (typeof data[config] === 'undefined') {
                                                                                                      throw new TypeError("No method named \"" + config + "\"");
                                                                                                    }
                                                                                        
                                                                                        
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 5 other locations - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 1370..1376
                                                                                        app/assets/javascripts/application.js on lines 1740..1746
                                                                                        app/assets/javascripts/application.js on lines 3097..3103
                                                                                        app/assets/javascripts/application.js on lines 3619..3625
                                                                                        app/assets/javascripts/application.js on lines 3878..3884

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 55.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                                  if (typeof config === 'string') {
                                                                                                    if (typeof data[config] === 'undefined') {
                                                                                                      throw new TypeError("No method named \"" + config + "\"");
                                                                                                    }
                                                                                        
                                                                                        
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 5 other locations - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 1370..1376
                                                                                        app/assets/javascripts/application.js on lines 1740..1746
                                                                                        app/assets/javascripts/application.js on lines 3097..3103
                                                                                        app/assets/javascripts/application.js on lines 3293..3299
                                                                                        app/assets/javascripts/application.js on lines 3878..3884

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 55.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                                  if (typeof config === 'string') {
                                                                                                    if (typeof data[config] === 'undefined') {
                                                                                                      throw new TypeError("No method named \"" + config + "\"");
                                                                                                    }
                                                                                        
                                                                                        
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 5 other locations - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 1370..1376
                                                                                        app/assets/javascripts/application.js on lines 1740..1746
                                                                                        app/assets/javascripts/application.js on lines 3097..3103
                                                                                        app/assets/javascripts/application.js on lines 3293..3299
                                                                                        app/assets/javascripts/application.js on lines 3619..3625

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 55.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                                  if (typeof config === 'string') {
                                                                                                    if (typeof data[config] === 'undefined') {
                                                                                                      throw new TypeError("No method named \"" + config + "\"");
                                                                                                    }
                                                                                        
                                                                                        
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 5 other locations - About 1 hr to fix
                                                                                        app/assets/javascripts/application.js on lines 1370..1376
                                                                                        app/assets/javascripts/application.js on lines 3097..3103
                                                                                        app/assets/javascripts/application.js on lines 3293..3299
                                                                                        app/assets/javascripts/application.js on lines 3619..3625
                                                                                        app/assets/javascripts/application.js on lines 3878..3884

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

                                                                                              _createClass(Carousel, null, [{
                                                                                                key: "VERSION",
                                                                                                get: function get() {
                                                                                                  return VERSION;
                                                                                                }
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 3 other locations - About 55 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 1380..1390
                                                                                        app/assets/javascripts/application.js on lines 2425..2435
                                                                                        app/assets/javascripts/application.js on lines 3629..3639

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

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                              _createClass(Collapse, null, [{
                                                                                                key: "VERSION",
                                                                                                get: function get() {
                                                                                                  return VERSION;
                                                                                                }
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 3 other locations - About 55 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 1019..1029
                                                                                        app/assets/javascripts/application.js on lines 2425..2435
                                                                                        app/assets/javascripts/application.js on lines 3629..3639

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

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                              _createClass(ScrollSpy, null, [{
                                                                                                key: "VERSION",
                                                                                                get: function get() {
                                                                                                  return VERSION;
                                                                                                }
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 3 other locations - About 55 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 1019..1029
                                                                                        app/assets/javascripts/application.js on lines 1380..1390
                                                                                        app/assets/javascripts/application.js on lines 2425..2435

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

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                              _createClass(Modal, null, [{
                                                                                                key: "VERSION",
                                                                                                get: function get() {
                                                                                                  return VERSION;
                                                                                                }
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 3 other locations - About 55 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 1019..1029
                                                                                        app/assets/javascripts/application.js on lines 1380..1390
                                                                                        app/assets/javascripts/application.js on lines 3629..3639

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

                                                                                        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

                                                                                              _proto._getConfig = function _getConfig(config) {
                                                                                                config = _objectSpread({}, Default, config);
                                                                                                Util.typeCheckConfig(NAME, config, DefaultType);
                                                                                                return config;
                                                                                              };
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 50 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 757..761

                                                                                        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

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

                                                                                              _proto._getConfig = function _getConfig(config) {
                                                                                                config = _objectSpread({}, Default, config);
                                                                                                Util.typeCheckConfig(NAME, config, DefaultType);
                                                                                                return config;
                                                                                              };
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 50 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 2124..2128

                                                                                        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

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

                                                                                                  if ('ontouchstart' in document.documentElement) {
                                                                                                    $$$1(document.body).children().off('mouseover', null, $$$1.noop);
                                                                                                  }
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 45 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 2818..2820

                                                                                        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

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

                                                                                                if ('ontouchstart' in document.documentElement) {
                                                                                                  $$$1(document.body).children().off('mouseover', null, $$$1.noop);
                                                                                                }
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 45 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 1792..1794

                                                                                        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

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

                                                                                              _proto.addAttachmentClass = function addAttachmentClass(attachment) {
                                                                                                $$$1(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
                                                                                              };
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 40 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 3239..3241

                                                                                        Duplicated Code

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

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

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

                                                                                        Tuning

                                                                                        This issue has a mass of 49.

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

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

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

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

                                                                                        Refactorings

                                                                                        Further Reading

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

                                                                                              _proto.addAttachmentClass = function addAttachmentClass(attachment) {
                                                                                                $$$1(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
                                                                                              };
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 40 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 2847..2849

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

                                                                                            var ClassName = {
                                                                                              CAROUSEL: 'carousel',
                                                                                              ACTIVE: 'active',
                                                                                              SLIDE: 'slide',
                                                                                              RIGHT: 'carousel-item-right',
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 2 other locations - About 40 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 1477..1486
                                                                                        app/assets/javascripts/application.js on lines 1494..1503

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

                                                                                        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

                                                                                            var AttachmentMap = {
                                                                                              TOP: 'top-start',
                                                                                              TOPEND: 'top-end',
                                                                                              BOTTOM: 'bottom-start',
                                                                                              BOTTOMEND: 'bottom-end',
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 2 other locations - About 40 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 618..627
                                                                                        app/assets/javascripts/application.js on lines 1477..1486

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

                                                                                        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

                                                                                            var ClassName = {
                                                                                              DISABLED: 'disabled',
                                                                                              SHOW: 'show',
                                                                                              DROPUP: 'dropup',
                                                                                              DROPRIGHT: 'dropright',
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 2 other locations - About 40 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 618..627
                                                                                        app/assets/javascripts/application.js on lines 1494..1503

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

                                                                                        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

                                                                                              _proto.dispose = function dispose() {
                                                                                                $$$1.removeData(this._element, DATA_KEY);
                                                                                                this._element = null;
                                                                                              }; // Private
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 2 other locations - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 290..293
                                                                                        app/assets/javascripts/application.js on lines 496..499

                                                                                        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

                                                                                                  $$$1(_this2._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).trigger(Event.HIDDEN);
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 1224..1224

                                                                                        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 (active && isTransitioning) {
                                                                                                  var transitionDuration = Util.getTransitionDurationFromElement(active);
                                                                                                  $$$1(active).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
                                                                                                } else {
                                                                                                  complete();
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 2826..2831

                                                                                        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

                                                                                                  $$$1(_this._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).addClass(ClassName.SHOW);
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 1280..1280

                                                                                        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 ($$$1(this.tip).hasClass(ClassName.FADE)) {
                                                                                                  var transitionDuration = Util.getTransitionDurationFromElement(tip);
                                                                                                  $$$1(tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
                                                                                                } else {
                                                                                                  complete();
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 3820..3825

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

                                                                                              _proto.dispose = function dispose() {
                                                                                                $$$1.removeData(this._element, DATA_KEY);
                                                                                                this._element = null;
                                                                                              }; // Private
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 2 other locations - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 496..499
                                                                                        app/assets/javascripts/application.js on lines 3796..3799

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

                                                                                              _proto.dispose = function dispose() {
                                                                                                $$$1.removeData(this._element, DATA_KEY);
                                                                                                this._element = null;
                                                                                              }; // Static
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 2 other locations - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 290..293
                                                                                        app/assets/javascripts/application.js on lines 3796..3799

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

                                                                                            $$$1.fn[NAME].noConflict = function () {
                                                                                              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
                                                                                              return Alert._jQueryInterface;
                                                                                            };
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 9 other locations - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 555..558
                                                                                        app/assets/javascripts/application.js on lines 1059..1062
                                                                                        app/assets/javascripts/application.js on lines 1427..1430
                                                                                        app/assets/javascripts/application.js on lines 1915..1918
                                                                                        app/assets/javascripts/application.js on lines 2486..2489
                                                                                        app/assets/javascripts/application.js on lines 3156..3159
                                                                                        app/assets/javascripts/application.js on lines 3353..3356
                                                                                        app/assets/javascripts/application.js on lines 3669..3672
                                                                                        app/assets/javascripts/application.js on lines 3918..3921

                                                                                        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 (!context.config.delay || !context.config.delay.show) {
                                                                                                  context.show();
                                                                                                  return;
                                                                                                }
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 2990..2993

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

                                                                                            $$$1.fn[NAME].noConflict = function () {
                                                                                              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
                                                                                              return Carousel._jQueryInterface;
                                                                                            };
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 9 other locations - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 391..394
                                                                                        app/assets/javascripts/application.js on lines 555..558
                                                                                        app/assets/javascripts/application.js on lines 1427..1430
                                                                                        app/assets/javascripts/application.js on lines 1915..1918
                                                                                        app/assets/javascripts/application.js on lines 2486..2489
                                                                                        app/assets/javascripts/application.js on lines 3156..3159
                                                                                        app/assets/javascripts/application.js on lines 3353..3356
                                                                                        app/assets/javascripts/application.js on lines 3669..3672
                                                                                        app/assets/javascripts/application.js on lines 3918..3921

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

                                                                                            $$$1.fn[NAME].noConflict = function () {
                                                                                              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
                                                                                              return Modal._jQueryInterface;
                                                                                            };
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 9 other locations - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 391..394
                                                                                        app/assets/javascripts/application.js on lines 555..558
                                                                                        app/assets/javascripts/application.js on lines 1059..1062
                                                                                        app/assets/javascripts/application.js on lines 1427..1430
                                                                                        app/assets/javascripts/application.js on lines 1915..1918
                                                                                        app/assets/javascripts/application.js on lines 3156..3159
                                                                                        app/assets/javascripts/application.js on lines 3353..3356
                                                                                        app/assets/javascripts/application.js on lines 3669..3672
                                                                                        app/assets/javascripts/application.js on lines 3918..3921

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

                                                                                            $$$1.fn[NAME].noConflict = function () {
                                                                                              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
                                                                                              return ScrollSpy._jQueryInterface;
                                                                                            };
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 9 other locations - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 391..394
                                                                                        app/assets/javascripts/application.js on lines 555..558
                                                                                        app/assets/javascripts/application.js on lines 1059..1062
                                                                                        app/assets/javascripts/application.js on lines 1427..1430
                                                                                        app/assets/javascripts/application.js on lines 1915..1918
                                                                                        app/assets/javascripts/application.js on lines 2486..2489
                                                                                        app/assets/javascripts/application.js on lines 3156..3159
                                                                                        app/assets/javascripts/application.js on lines 3353..3356
                                                                                        app/assets/javascripts/application.js on lines 3918..3921

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

                                                                                            $$$1.fn[NAME].noConflict = function () {
                                                                                              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
                                                                                              return Tab._jQueryInterface;
                                                                                            };
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 9 other locations - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 391..394
                                                                                        app/assets/javascripts/application.js on lines 555..558
                                                                                        app/assets/javascripts/application.js on lines 1059..1062
                                                                                        app/assets/javascripts/application.js on lines 1427..1430
                                                                                        app/assets/javascripts/application.js on lines 1915..1918
                                                                                        app/assets/javascripts/application.js on lines 2486..2489
                                                                                        app/assets/javascripts/application.js on lines 3156..3159
                                                                                        app/assets/javascripts/application.js on lines 3353..3356
                                                                                        app/assets/javascripts/application.js on lines 3669..3672

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

                                                                                            $$$1.fn[NAME].noConflict = function () {
                                                                                              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
                                                                                              return Collapse._jQueryInterface;
                                                                                            };
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 9 other locations - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 391..394
                                                                                        app/assets/javascripts/application.js on lines 555..558
                                                                                        app/assets/javascripts/application.js on lines 1059..1062
                                                                                        app/assets/javascripts/application.js on lines 1915..1918
                                                                                        app/assets/javascripts/application.js on lines 2486..2489
                                                                                        app/assets/javascripts/application.js on lines 3156..3159
                                                                                        app/assets/javascripts/application.js on lines 3353..3356
                                                                                        app/assets/javascripts/application.js on lines 3669..3672
                                                                                        app/assets/javascripts/application.js on lines 3918..3921

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

                                                                                            $$$1.fn[NAME].noConflict = function () {
                                                                                              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
                                                                                              return Popover._jQueryInterface;
                                                                                            };
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 9 other locations - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 391..394
                                                                                        app/assets/javascripts/application.js on lines 555..558
                                                                                        app/assets/javascripts/application.js on lines 1059..1062
                                                                                        app/assets/javascripts/application.js on lines 1427..1430
                                                                                        app/assets/javascripts/application.js on lines 1915..1918
                                                                                        app/assets/javascripts/application.js on lines 2486..2489
                                                                                        app/assets/javascripts/application.js on lines 3156..3159
                                                                                        app/assets/javascripts/application.js on lines 3669..3672
                                                                                        app/assets/javascripts/application.js on lines 3918..3921

                                                                                        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 (!context.config.delay || !context.config.delay.hide) {
                                                                                                  context.hide();
                                                                                                  return;
                                                                                                }
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 2958..2961

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

                                                                                            $$$1.fn[NAME].noConflict = function () {
                                                                                              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
                                                                                              return Dropdown._jQueryInterface;
                                                                                            };
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 9 other locations - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 391..394
                                                                                        app/assets/javascripts/application.js on lines 555..558
                                                                                        app/assets/javascripts/application.js on lines 1059..1062
                                                                                        app/assets/javascripts/application.js on lines 1427..1430
                                                                                        app/assets/javascripts/application.js on lines 2486..2489
                                                                                        app/assets/javascripts/application.js on lines 3156..3159
                                                                                        app/assets/javascripts/application.js on lines 3353..3356
                                                                                        app/assets/javascripts/application.js on lines 3669..3672
                                                                                        app/assets/javascripts/application.js on lines 3918..3921

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

                                                                                            $$$1.fn[NAME].noConflict = function () {
                                                                                              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
                                                                                              return Button._jQueryInterface;
                                                                                            };
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 9 other locations - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 391..394
                                                                                        app/assets/javascripts/application.js on lines 1059..1062
                                                                                        app/assets/javascripts/application.js on lines 1427..1430
                                                                                        app/assets/javascripts/application.js on lines 1915..1918
                                                                                        app/assets/javascripts/application.js on lines 2486..2489
                                                                                        app/assets/javascripts/application.js on lines 3156..3159
                                                                                        app/assets/javascripts/application.js on lines 3353..3356
                                                                                        app/assets/javascripts/application.js on lines 3669..3672
                                                                                        app/assets/javascripts/application.js on lines 3918..3921

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

                                                                                            $$$1.fn[NAME].noConflict = function () {
                                                                                              $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
                                                                                              return Tooltip._jQueryInterface;
                                                                                            };
                                                                                        Severity: Major
                                                                                        Found in app/assets/javascripts/application.js and 9 other locations - About 35 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 391..394
                                                                                        app/assets/javascripts/application.js on lines 555..558
                                                                                        app/assets/javascripts/application.js on lines 1059..1062
                                                                                        app/assets/javascripts/application.js on lines 1427..1430
                                                                                        app/assets/javascripts/application.js on lines 1915..1918
                                                                                        app/assets/javascripts/application.js on lines 2486..2489
                                                                                        app/assets/javascripts/application.js on lines 3353..3356
                                                                                        app/assets/javascripts/application.js on lines 3669..3672
                                                                                        app/assets/javascripts/application.js on lines 3918..3921

                                                                                        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

                                                                                            var Selector = {
                                                                                              DROPDOWN: '.dropdown',
                                                                                              NAV_LIST_GROUP: '.nav, .list-group',
                                                                                              ACTIVE: '.active',
                                                                                              ACTIVE_UL: '> li > .active',
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 30 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 628..642

                                                                                        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

                                                                                              _proto.prev = function prev() {
                                                                                                if (!this._isSliding) {
                                                                                                  this._slide(Direction.PREV);
                                                                                                }
                                                                                              };
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 30 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 665..669

                                                                                        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

                                                                                                    var eventOut = trigger === Trigger.HOVER ? _this3.constructor.Event.MOUSELEAVE : _this3.constructor.Event.FOCUSOUT;
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 30 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 2904..2904

                                                                                        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

                                                                                            var Selector = {
                                                                                              ACTIVE: '.active',
                                                                                              ACTIVE_ITEM: '.active.carousel-item',
                                                                                              ITEM: '.carousel-item',
                                                                                              NEXT_PREV: '.carousel-item-next, .carousel-item-prev',
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 30 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 3710..3724

                                                                                        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

                                                                                              _proto.next = function next() {
                                                                                                if (!this._isSliding) {
                                                                                                  this._slide(Direction.NEXT);
                                                                                                }
                                                                                              };
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 30 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 679..683

                                                                                        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

                                                                                                    var eventIn = trigger === Trigger.HOVER ? _this3.constructor.Event.MOUSEENTER : _this3.constructor.Event.FOCUSIN;
                                                                                        Severity: Minor
                                                                                        Found in app/assets/javascripts/application.js and 1 other location - About 30 mins to fix
                                                                                        app/assets/javascripts/application.js on lines 2905..2905

                                                                                        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