VSVverkeerskunde/gvq-api

View on GitHub
public/js/bootstrap.js

Summary

Maintainability
F
1 mo
Test Coverage

File bootstrap.js has 2812 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*!
  * Bootstrap v4.1.0 (https://getbootstrap.com/)
  * Copyright 2011-2018 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  */
Severity: Major
Found in public/js/bootstrap.js - About 1 wk to fix

    Function Tooltip has 513 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

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

      Function Tooltip has 430 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

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

        Function Modal has 418 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

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

          Function Carousel has 366 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

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

            Function Modal has 338 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                function () {
                  function Modal(element, config) {
                    this._config = this._getConfig(config);
                    this._element = element;
                    this._dialog = $$$1(element).find(Selector.DIALOG)[0];
            Severity: Major
            Found in public/js/bootstrap.js - About 1 day to fix

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

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

                Function Carousel has 291 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

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

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

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

                    Function Dropdown has 249 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 public/js/bootstrap.js - About 1 day to fix

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

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

                        Function Collapse has 196 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 public/js/bootstrap.js - About 7 hrs to fix

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

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

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

                                function () {
                                  function ScrollSpy(element, config) {
                                    var _this = this;
                            
                                    this._element = element;
                            Severity: Major
                            Found in public/js/bootstrap.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 public/js/bootstrap.js - About 5 hrs to fix

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

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

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

                                    var Alert = function ($$$1) {
                                      /**
                                       * ------------------------------------------------------------------------
                                       * Constants
                                       * ------------------------------------------------------------------------
                                  Severity: Major
                                  Found in public/js/bootstrap.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 public/js/bootstrap.js - About 4 hrs to fix

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

                                        var Util = function ($$$1) {
                                          /**
                                           * ------------------------------------------------------------------------
                                           * Private TransitionEnd Helpers
                                           * ------------------------------------------------------------------------
                                      Severity: Major
                                      Found in public/js/bootstrap.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 public/js/bootstrap.js - About 3 hrs to fix

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

                                              function () {
                                                function Alert(element) {
                                                  this._element = element;
                                                } // Getters
                                          
                                          
                                          Severity: Major
                                          Found in public/js/bootstrap.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 public/js/bootstrap.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 = $$$1(this._element).find(Selector.ACTIVE_ITEM)[0];
                                              
                                              
                                              Severity: Major
                                              Found in public/js/bootstrap.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 public/js/bootstrap.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 public/js/bootstrap.js - About 2 hrs to fix

                                                    Function show has 47 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 public/js/bootstrap.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 public/js/bootstrap.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 public/js/bootstrap.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 public/js/bootstrap.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 public/js/bootstrap.js - About 1 hr to fix

                                                              Function hide has 33 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 public/js/bootstrap.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 public/js/bootstrap.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 public/js/bootstrap.js - About 1 hr to fix

                                                                    Function _clearMenus has 32 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 public/js/bootstrap.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 public/js/bootstrap.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 public/js/bootstrap.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 public/js/bootstrap.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 public/js/bootstrap.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 public/js/bootstrap.js - About 1 hr to fix

                                                                                Function _transitionComplete has 26 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 public/js/bootstrap.js - About 1 hr to fix

                                                                                  Avoid deeply nested control flow statements.
                                                                                  Open

                                                                                                  if (activeElement) {
                                                                                                    $$$1(activeElement).removeClass(ClassName.ACTIVE);
                                                                                                  }
                                                                                  Severity: Major
                                                                                  Found in public/js/bootstrap.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 public/js/bootstrap.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 public/js/bootstrap.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 = $$$1(parent).find(Selector.DATA_TOGGLE)[0];
                                                                                                    $$$1(toggle).trigger('focus');
                                                                                                  }
                                                                                        Severity: Major
                                                                                        Found in public/js/bootstrap.js - About 40 mins to fix

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

                                                                                                    $$$1(Selector.STICKY_CONTENT).each(function (index, element) {
                                                                                                      var actualMargin = $$$1(element)[0].style.marginRight;
                                                                                                      var calculatedMargin = $$$1(element).css('margin-right');
                                                                                                      $$$1(element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) - _this9._scrollbarWidth + "px");
                                                                                                    }); // Adjust navbar-toggler margin
                                                                                          Severity: Major
                                                                                          Found in public/js/bootstrap.js and 1 other location - About 3 hrs to fix
                                                                                          public/js/bootstrap.js on lines 2322..2326

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

                                                                                          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(Selector.NAVBAR_TOGGLER).each(function (index, element) {
                                                                                                      var actualMargin = $$$1(element)[0].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 public/js/bootstrap.js and 1 other location - About 3 hrs to fix
                                                                                          public/js/bootstrap.js on lines 2316..2320

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

                                                                                          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._cleanTipClass = function _cleanTipClass() {
                                                                                                  var $tip = $$$1(this.getTipElement());
                                                                                                  var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
                                                                                          
                                                                                                  if (tabClass !== null && tabClass.length > 0) {
                                                                                          Severity: Major
                                                                                          Found in public/js/bootstrap.js and 1 other location - About 3 hrs to fix
                                                                                          public/js/bootstrap.js on lines 3233..3240

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

                                                                                          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._cleanTipClass = function _cleanTipClass() {
                                                                                                  var $tip = $$$1(this.getTipElement());
                                                                                                  var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
                                                                                          
                                                                                                  if (tabClass !== null && tabClass.length > 0) {
                                                                                          Severity: Major
                                                                                          Found in public/js/bootstrap.js and 1 other location - About 3 hrs to fix
                                                                                          public/js/bootstrap.js on lines 3016..3023

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

                                                                                          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 public/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                                                                          public/js/bootstrap.js on lines 2264..2270

                                                                                          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._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 public/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                                                                          public/js/bootstrap.js on lines 2742..2747

                                                                                          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 (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 public/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 1548..1554

                                                                                          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

                                                                                                    } 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 public/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 1289..1297

                                                                                          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

                                                                                                  $$$1(Selector.STICKY_CONTENT + ", " + Selector.NAVBAR_TOGGLER).each(function (index, element) {
                                                                                                    var margin = $$$1(element).data('margin-right');
                                                                                          
                                                                                                    if (typeof margin !== 'undefined') {
                                                                                                      $$$1(element).css('margin-right', margin).removeData('margin-right');
                                                                                          Severity: Major
                                                                                          Found in public/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 2336..2342

                                                                                          Duplicated Code

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

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

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

                                                                                          Tuning

                                                                                          This issue has a mass of 65.

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

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

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

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

                                                                                          Refactorings

                                                                                          Further Reading

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

                                                                                                  $$$1(Selector.FIXED_CONTENT).each(function (index, element) {
                                                                                                    var padding = $$$1(element).data('padding-right');
                                                                                          
                                                                                                    if (typeof padding !== 'undefined') {
                                                                                                      $$$1(element).css('padding-right', padding).removeData('padding-right');
                                                                                          Severity: Major
                                                                                          Found in public/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 2344..2350

                                                                                          Duplicated Code

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

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

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

                                                                                          Tuning

                                                                                          This issue has a mass of 65.

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

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

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

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

                                                                                          Refactorings

                                                                                          Further Reading

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

                                                                                                  context._timeout = setTimeout(function () {
                                                                                                    if (context._hoverState === HoverState.SHOW) {
                                                                                                      context.show();
                                                                                                    }
                                                                                                  }, context.config.delay.show);
                                                                                          Severity: Major
                                                                                          Found in public/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                                          public/js/bootstrap.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

                                                                                          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 public/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 2931..2935

                                                                                          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 public/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 3208..3211

                                                                                          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 public/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 2819..2822

                                                                                          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 = {
                                                                                                HIDE: "hide" + EVENT_KEY,
                                                                                                HIDDEN: "hidden" + EVENT_KEY,
                                                                                                SHOW: "show" + EVENT_KEY,
                                                                                                SHOWN: "shown" + EVENT_KEY,
                                                                                          Severity: Major
                                                                                          Found in public/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 1069..1075

                                                                                          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 = {
                                                                                                SHOW: "show" + EVENT_KEY,
                                                                                                SHOWN: "shown" + EVENT_KEY,
                                                                                                HIDE: "hide" + EVENT_KEY,
                                                                                                HIDDEN: "hidden" + EVENT_KEY,
                                                                                          Severity: Major
                                                                                          Found in public/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 3657..3663

                                                                                          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 public/js/bootstrap.js and 2 other locations - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 2909..2912
                                                                                          public/js/bootstrap.js on lines 2942..2945

                                                                                          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 public/js/bootstrap.js and 2 other locations - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 2606..2609
                                                                                          public/js/bootstrap.js on lines 2942..2945

                                                                                          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 public/js/bootstrap.js and 2 other locations - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 2606..2609
                                                                                          public/js/bootstrap.js on lines 2909..2912

                                                                                          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 public/js/bootstrap.js and 5 other locations - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 1338..1344
                                                                                          public/js/bootstrap.js on lines 3062..3068
                                                                                          public/js/bootstrap.js on lines 3258..3264
                                                                                          public/js/bootstrap.js on lines 3581..3587
                                                                                          public/js/bootstrap.js on lines 3838..3844

                                                                                          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 public/js/bootstrap.js and 5 other locations - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 1705..1711
                                                                                          public/js/bootstrap.js on lines 3062..3068
                                                                                          public/js/bootstrap.js on lines 3258..3264
                                                                                          public/js/bootstrap.js on lines 3581..3587
                                                                                          public/js/bootstrap.js on lines 3838..3844

                                                                                          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 public/js/bootstrap.js and 5 other locations - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 1338..1344
                                                                                          public/js/bootstrap.js on lines 1705..1711
                                                                                          public/js/bootstrap.js on lines 3062..3068
                                                                                          public/js/bootstrap.js on lines 3581..3587
                                                                                          public/js/bootstrap.js on lines 3838..3844

                                                                                          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 public/js/bootstrap.js and 5 other locations - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 1338..1344
                                                                                          public/js/bootstrap.js on lines 1705..1711
                                                                                          public/js/bootstrap.js on lines 3062..3068
                                                                                          public/js/bootstrap.js on lines 3258..3264
                                                                                          public/js/bootstrap.js on lines 3838..3844

                                                                                          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 public/js/bootstrap.js and 5 other locations - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 1338..1344
                                                                                          public/js/bootstrap.js on lines 1705..1711
                                                                                          public/js/bootstrap.js on lines 3062..3068
                                                                                          public/js/bootstrap.js on lines 3258..3264
                                                                                          public/js/bootstrap.js on lines 3581..3587

                                                                                          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 public/js/bootstrap.js and 5 other locations - About 1 hr to fix
                                                                                          public/js/bootstrap.js on lines 1338..1344
                                                                                          public/js/bootstrap.js on lines 1705..1711
                                                                                          public/js/bootstrap.js on lines 3258..3264
                                                                                          public/js/bootstrap.js on lines 3581..3587
                                                                                          public/js/bootstrap.js on lines 3838..3844

                                                                                          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(Collapse, null, [{
                                                                                                  key: "VERSION",
                                                                                                  get: function get() {
                                                                                                    return VERSION;
                                                                                                  }
                                                                                          Severity: Major
                                                                                          Found in public/js/bootstrap.js and 3 other locations - About 55 mins to fix
                                                                                          public/js/bootstrap.js on lines 996..1006
                                                                                          public/js/bootstrap.js on lines 2393..2403
                                                                                          public/js/bootstrap.js on lines 3591..3601

                                                                                          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 public/js/bootstrap.js and 3 other locations - About 55 mins to fix
                                                                                          public/js/bootstrap.js on lines 996..1006
                                                                                          public/js/bootstrap.js on lines 1348..1358
                                                                                          public/js/bootstrap.js on lines 2393..2403

                                                                                          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 public/js/bootstrap.js and 3 other locations - About 55 mins to fix
                                                                                          public/js/bootstrap.js on lines 996..1006
                                                                                          public/js/bootstrap.js on lines 1348..1358
                                                                                          public/js/bootstrap.js on lines 3591..3601

                                                                                          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(Carousel, null, [{
                                                                                                  key: "VERSION",
                                                                                                  get: function get() {
                                                                                                    return VERSION;
                                                                                                  }
                                                                                          Severity: Major
                                                                                          Found in public/js/bootstrap.js and 3 other locations - About 55 mins to fix
                                                                                          public/js/bootstrap.js on lines 1348..1358
                                                                                          public/js/bootstrap.js on lines 2393..2403
                                                                                          public/js/bootstrap.js on lines 3591..3601

                                                                                          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 public/js/bootstrap.js and 1 other location - About 50 mins to fix
                                                                                          public/js/bootstrap.js on lines 735..739

                                                                                          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 public/js/bootstrap.js and 1 other location - About 50 mins to fix
                                                                                          public/js/bootstrap.js on lines 2086..2090

                                                                                          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 public/js/bootstrap.js and 1 other location - About 45 mins to fix
                                                                                          public/js/bootstrap.js on lines 2786..2788

                                                                                          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 public/js/bootstrap.js and 1 other location - About 45 mins to fix
                                                                                          public/js/bootstrap.js on lines 1753..1755

                                                                                          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 public/js/bootstrap.js and 1 other location - About 40 mins to fix
                                                                                          public/js/bootstrap.js on lines 3204..3206

                                                                                          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 public/js/bootstrap.js and 1 other location - About 40 mins to fix
                                                                                          public/js/bootstrap.js on lines 2815..2817

                                                                                          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 = {
                                                                                                DISABLED: 'disabled',
                                                                                                SHOW: 'show',
                                                                                                DROPUP: 'dropup',
                                                                                                DROPRIGHT: 'dropright',
                                                                                          Severity: Minor
                                                                                          Found in public/js/bootstrap.js and 2 other locations - About 40 mins to fix
                                                                                          public/js/bootstrap.js on lines 596..605
                                                                                          public/js/bootstrap.js on lines 1461..1470

                                                                                          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 = {
                                                                                                CAROUSEL: 'carousel',
                                                                                                ACTIVE: 'active',
                                                                                                SLIDE: 'slide',
                                                                                                RIGHT: 'carousel-item-right',
                                                                                          Severity: Minor
                                                                                          Found in public/js/bootstrap.js and 2 other locations - About 40 mins to fix
                                                                                          public/js/bootstrap.js on lines 1444..1453
                                                                                          public/js/bootstrap.js on lines 1461..1470

                                                                                          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 public/js/bootstrap.js and 2 other locations - About 40 mins to fix
                                                                                          public/js/bootstrap.js on lines 596..605
                                                                                          public/js/bootstrap.js on lines 1444..1453

                                                                                          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 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 public/js/bootstrap.js and 1 other location - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 2794..2799

                                                                                          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 public/js/bootstrap.js and 2 other locations - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 474..477
                                                                                          public/js/bootstrap.js on lines 3757..3760

                                                                                          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 public/js/bootstrap.js and 2 other locations - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 268..271
                                                                                          public/js/bootstrap.js on lines 474..477

                                                                                          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 public/js/bootstrap.js and 1 other location - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 1249..1249

                                                                                          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 public/js/bootstrap.js and 1 other location - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 1194..1194

                                                                                          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 public/js/bootstrap.js and 2 other locations - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 268..271
                                                                                          public/js/bootstrap.js on lines 3757..3760

                                                                                          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 public/js/bootstrap.js and 1 other location - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 3781..3786

                                                                                          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 Tooltip._jQueryInterface;
                                                                                              };
                                                                                          Severity: Major
                                                                                          Found in public/js/bootstrap.js and 9 other locations - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 369..372
                                                                                          public/js/bootstrap.js on lines 533..536
                                                                                          public/js/bootstrap.js on lines 1034..1037
                                                                                          public/js/bootstrap.js on lines 1394..1397
                                                                                          public/js/bootstrap.js on lines 1876..1879
                                                                                          public/js/bootstrap.js on lines 2454..2457
                                                                                          public/js/bootstrap.js on lines 3318..3321
                                                                                          public/js/bootstrap.js on lines 3630..3633
                                                                                          public/js/bootstrap.js on lines 3878..3881

                                                                                          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 public/js/bootstrap.js and 9 other locations - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 369..372
                                                                                          public/js/bootstrap.js on lines 533..536
                                                                                          public/js/bootstrap.js on lines 1394..1397
                                                                                          public/js/bootstrap.js on lines 1876..1879
                                                                                          public/js/bootstrap.js on lines 2454..2457
                                                                                          public/js/bootstrap.js on lines 3121..3124
                                                                                          public/js/bootstrap.js on lines 3318..3321
                                                                                          public/js/bootstrap.js on lines 3630..3633
                                                                                          public/js/bootstrap.js on lines 3878..3881

                                                                                          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 public/js/bootstrap.js and 9 other locations - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 369..372
                                                                                          public/js/bootstrap.js on lines 533..536
                                                                                          public/js/bootstrap.js on lines 1034..1037
                                                                                          public/js/bootstrap.js on lines 1876..1879
                                                                                          public/js/bootstrap.js on lines 2454..2457
                                                                                          public/js/bootstrap.js on lines 3121..3124
                                                                                          public/js/bootstrap.js on lines 3318..3321
                                                                                          public/js/bootstrap.js on lines 3630..3633
                                                                                          public/js/bootstrap.js on lines 3878..3881

                                                                                          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 public/js/bootstrap.js and 9 other locations - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 369..372
                                                                                          public/js/bootstrap.js on lines 533..536
                                                                                          public/js/bootstrap.js on lines 1034..1037
                                                                                          public/js/bootstrap.js on lines 1394..1397
                                                                                          public/js/bootstrap.js on lines 2454..2457
                                                                                          public/js/bootstrap.js on lines 3121..3124
                                                                                          public/js/bootstrap.js on lines 3318..3321
                                                                                          public/js/bootstrap.js on lines 3630..3633
                                                                                          public/js/bootstrap.js on lines 3878..3881

                                                                                          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 public/js/bootstrap.js and 9 other locations - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 369..372
                                                                                          public/js/bootstrap.js on lines 1034..1037
                                                                                          public/js/bootstrap.js on lines 1394..1397
                                                                                          public/js/bootstrap.js on lines 1876..1879
                                                                                          public/js/bootstrap.js on lines 2454..2457
                                                                                          public/js/bootstrap.js on lines 3121..3124
                                                                                          public/js/bootstrap.js on lines 3318..3321
                                                                                          public/js/bootstrap.js on lines 3630..3633
                                                                                          public/js/bootstrap.js on lines 3878..3881

                                                                                          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 public/js/bootstrap.js and 9 other locations - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 369..372
                                                                                          public/js/bootstrap.js on lines 533..536
                                                                                          public/js/bootstrap.js on lines 1034..1037
                                                                                          public/js/bootstrap.js on lines 1394..1397
                                                                                          public/js/bootstrap.js on lines 1876..1879
                                                                                          public/js/bootstrap.js on lines 2454..2457
                                                                                          public/js/bootstrap.js on lines 3121..3124
                                                                                          public/js/bootstrap.js on lines 3630..3633
                                                                                          public/js/bootstrap.js on lines 3878..3881

                                                                                          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 public/js/bootstrap.js and 9 other locations - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 369..372
                                                                                          public/js/bootstrap.js on lines 533..536
                                                                                          public/js/bootstrap.js on lines 1034..1037
                                                                                          public/js/bootstrap.js on lines 1394..1397
                                                                                          public/js/bootstrap.js on lines 1876..1879
                                                                                          public/js/bootstrap.js on lines 2454..2457
                                                                                          public/js/bootstrap.js on lines 3121..3124
                                                                                          public/js/bootstrap.js on lines 3318..3321
                                                                                          public/js/bootstrap.js on lines 3878..3881

                                                                                          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 Alert._jQueryInterface;
                                                                                              };
                                                                                          Severity: Major
                                                                                          Found in public/js/bootstrap.js and 9 other locations - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 533..536
                                                                                          public/js/bootstrap.js on lines 1034..1037
                                                                                          public/js/bootstrap.js on lines 1394..1397
                                                                                          public/js/bootstrap.js on lines 1876..1879
                                                                                          public/js/bootstrap.js on lines 2454..2457
                                                                                          public/js/bootstrap.js on lines 3121..3124
                                                                                          public/js/bootstrap.js on lines 3318..3321
                                                                                          public/js/bootstrap.js on lines 3630..3633
                                                                                          public/js/bootstrap.js on lines 3878..3881

                                                                                          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 public/js/bootstrap.js and 9 other locations - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 369..372
                                                                                          public/js/bootstrap.js on lines 533..536
                                                                                          public/js/bootstrap.js on lines 1034..1037
                                                                                          public/js/bootstrap.js on lines 1394..1397
                                                                                          public/js/bootstrap.js on lines 1876..1879
                                                                                          public/js/bootstrap.js on lines 3121..3124
                                                                                          public/js/bootstrap.js on lines 3318..3321
                                                                                          public/js/bootstrap.js on lines 3630..3633
                                                                                          public/js/bootstrap.js on lines 3878..3881

                                                                                          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 public/js/bootstrap.js and 9 other locations - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 369..372
                                                                                          public/js/bootstrap.js on lines 533..536
                                                                                          public/js/bootstrap.js on lines 1034..1037
                                                                                          public/js/bootstrap.js on lines 1394..1397
                                                                                          public/js/bootstrap.js on lines 1876..1879
                                                                                          public/js/bootstrap.js on lines 2454..2457
                                                                                          public/js/bootstrap.js on lines 3121..3124
                                                                                          public/js/bootstrap.js on lines 3318..3321
                                                                                          public/js/bootstrap.js on lines 3630..3633

                                                                                          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 public/js/bootstrap.js and 1 other location - About 35 mins to fix
                                                                                          public/js/bootstrap.js on lines 2926..2929

                                                                                          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 public/js/bootstrap.js and 1 other location - About 35 mins to fix
                                                                                          public/js/bootstrap.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 2 locations. Consider refactoring.
                                                                                          Open

                                                                                                _proto.next = function next() {
                                                                                                  if (!this._isSliding) {
                                                                                                    this._slide(Direction.NEXT);
                                                                                                  }
                                                                                                };
                                                                                          Severity: Minor
                                                                                          Found in public/js/bootstrap.js and 1 other location - About 30 mins to fix
                                                                                          public/js/bootstrap.js on lines 657..661

                                                                                          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 public/js/bootstrap.js and 1 other location - About 30 mins to fix
                                                                                          public/js/bootstrap.js on lines 2873..2873

                                                                                          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 public/js/bootstrap.js and 1 other location - About 30 mins to fix
                                                                                          public/js/bootstrap.js on lines 3671..3685

                                                                                          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 = {
                                                                                                DROPDOWN: '.dropdown',
                                                                                                NAV_LIST_GROUP: '.nav, .list-group',
                                                                                                ACTIVE: '.active',
                                                                                                ACTIVE_UL: '> li > .active',
                                                                                          Severity: Minor
                                                                                          Found in public/js/bootstrap.js and 1 other location - About 30 mins to fix
                                                                                          public/js/bootstrap.js on lines 606..620

                                                                                          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 public/js/bootstrap.js and 1 other location - About 30 mins to fix
                                                                                          public/js/bootstrap.js on lines 643..647

                                                                                          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 public/js/bootstrap.js and 1 other location - About 30 mins to fix
                                                                                          public/js/bootstrap.js on lines 2872..2872

                                                                                          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