olneyhymn/westminster-daily

View on GitHub
static/js/bootstrap.js

Summary

Maintainability
F
1 mo
Test Coverage

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

/*!
  * Bootstrap v4.2.1 (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 static/js/bootstrap.js - About 1 wk to fix

    Function Tooltip has 444 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 static/js/bootstrap.js - About 2 days to fix

      Function Carousel has 363 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 static/js/bootstrap.js - About 1 day to fix

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

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

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

            Function Collapse has 204 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 static/js/bootstrap.js - About 1 day to fix

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

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

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

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

                  Function Toast has 109 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                    function () {
                      function Toast(element, config) {
                        this._element = element;
                        this._config = this._getConfig(config);
                        this._timeout = null;
                  Severity: Major
                  Found in static/js/bootstrap.js - About 4 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 static/js/bootstrap.js - About 3 hrs to fix

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

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

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

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

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

                              _proto._slide = function _slide(direction, element) {
                                var _this4 = this;
                          
                                var activeElement = this._element.querySelector(Selector$2.ACTIVE_ITEM);
                          
                          
                          Severity: Major
                          Found in static/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 static/js/bootstrap.js - About 2 hrs to fix

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

                                  _proto._addTouchEventListeners = function _addTouchEventListeners() {
                                    var _this3 = this;
                              
                                    if (!this._touchSupported) {
                                      return;
                              Severity: Major
                              Found in static/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 = $(this._element).hasClass(ClassName$5.FADE) ? ClassName$5.FADE : '';
                                
                                
                                Severity: Major
                                Found in static/js/bootstrap.js - About 2 hrs to fix

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

                                      _proto.show = function show() {
                                        var _this = this;
                                  
                                        if (this._isTransitioning || $(this._element).hasClass(ClassName$3.SHOW)) {
                                          return;
                                  Severity: Major
                                  Found in static/js/bootstrap.js - About 2 hrs 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 && $(this._element).hasClass(ClassName$9.ACTIVE) || $(this._element).hasClass(ClassName$9.DISABLED)) {
                                            return;
                                    Severity: Minor
                                    Found in static/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 || $(this._element).hasClass(ClassName$4.DISABLED)) {
                                              return;
                                            }
                                      
                                      
                                      Severity: Minor
                                      Found in static/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 = $.Event(this.constructor.Event.HIDE);
                                        Severity: Minor
                                        Found in static/js/bootstrap.js - About 1 hr to fix

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

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

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

                                                _proto.hide = function hide() {
                                                  var _this2 = this;
                                            
                                                  if (this._isTransitioning || !$(this._element).hasClass(ClassName$3.SHOW)) {
                                                    return;
                                            Severity: Minor
                                            Found in static/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 static/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 = $(this._element).closest(Selector$1.DATA_TOGGLE)[0];
                                                
                                                
                                                Severity: Minor
                                                Found in static/js/bootstrap.js - About 1 hr to fix

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

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

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

                                                        _proto._showElement = function _showElement(relatedTarget) {
                                                          var _this3 = this;
                                                    
                                                          var transition = $(this._element).hasClass(ClassName$5.FADE);
                                                    
                                                    
                                                    Severity: Minor
                                                    Found in static/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 static/js/bootstrap.js - About 1 hr to fix

                                                        Function _setListeners has 30 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 static/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 static/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 static/js/bootstrap.js - About 1 hr to fix

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

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

                                                                Avoid deeply nested control flow statements.
                                                                Open

                                                                              if (activeElement) {
                                                                                $(activeElement).removeClass(ClassName$1.ACTIVE);
                                                                              }
                                                                Severity: Major
                                                                Found in static/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) && $.contains(parent, event.target)) {
                                                                            continue;
                                                                          }
                                                                  Severity: Major
                                                                  Found in static/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 static/js/bootstrap.js - About 40 mins to fix

                                                                      Avoid too many return statements within this function.
                                                                      Open

                                                                            return Util.findShadowRoot(element.parentNode);
                                                                      Severity: Major
                                                                      Found in static/js/bootstrap.js - About 30 mins to fix

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

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

                                                                        Duplicated Code

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

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

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

                                                                        Tuning

                                                                        This issue has a mass of 101.

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

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

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

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

                                                                        Refactorings

                                                                        Further Reading

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

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

                                                                        Duplicated Code

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

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

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

                                                                        Tuning

                                                                        This issue has a mass of 101.

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

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

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

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

                                                                        Refactorings

                                                                        Further Reading

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

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

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

                                                                        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

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

                                                                              if (this._config.animation) {
                                                                                var transitionDuration = Util.getTransitionDurationFromElement(this._element);
                                                                                $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
                                                                              } else {
                                                                                complete();
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                                                        static/js/bootstrap.js on lines 4083..4088

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

                                                                        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 (this._config.animation) {
                                                                                var transitionDuration = Util.getTransitionDurationFromElement(this._element);
                                                                                $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
                                                                              } else {
                                                                                complete();
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                                                        static/js/bootstrap.js on lines 4149..4154

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

                                                                        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 static/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                        static/js/bootstrap.js on lines 1389..1397

                                                                        Duplicated Code

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

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

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

                                                                        Tuning

                                                                        This issue has a mass of 67.

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

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

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

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

                                                                        Refactorings

                                                                        Further Reading

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

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

                                                                        Duplicated Code

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

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

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

                                                                        Tuning

                                                                        This issue has a mass of 67.

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

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

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

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

                                                                        Refactorings

                                                                        Further Reading

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

                                                                              context._timeout = setTimeout(function () {
                                                                                if (context._hoverState === HoverState.OUT) {
                                                                                  context.hide();
                                                                                }
                                                                              }, context.config.delay.hide);
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                        static/js/bootstrap.js on lines 3075..3079

                                                                        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.SHOW) {
                                                                                  context.show();
                                                                                }
                                                                              }, context.config.delay.show);
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                        static/js/bootstrap.js on lines 3107..3111

                                                                        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 || $(this.config.template)[0];
                                                                              return this.tip;
                                                                            };
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                        static/js/bootstrap.js on lines 3345..3348

                                                                        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 || $(this.config.template)[0];
                                                                              return this.tip;
                                                                            };
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 1 other location - About 1 hr to fix
                                                                        static/js/bootstrap.js on lines 2950..2953

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

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

                                                                        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());
                                                                                $(event.currentTarget).data(dataKey, context);
                                                                              }
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 2 other locations - About 1 hr to fix
                                                                        static/js/bootstrap.js on lines 2734..2737
                                                                        static/js/bootstrap.js on lines 3086..3089

                                                                        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());
                                                                                  $(event.currentTarget).data(dataKey, context);
                                                                                }
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 2 other locations - About 1 hr to fix
                                                                        static/js/bootstrap.js on lines 3053..3056
                                                                        static/js/bootstrap.js on lines 3086..3089

                                                                        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());
                                                                                $(event.currentTarget).data(dataKey, context);
                                                                              }
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 2 other locations - About 1 hr to fix
                                                                        static/js/bootstrap.js on lines 2734..2737
                                                                        static/js/bootstrap.js on lines 3053..3056

                                                                        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 static/js/bootstrap.js and 5 other locations - About 1 hr to fix
                                                                        static/js/bootstrap.js on lines 1437..1443
                                                                        static/js/bootstrap.js on lines 1841..1847
                                                                        static/js/bootstrap.js on lines 3209..3215
                                                                        static/js/bootstrap.js on lines 3395..3401
                                                                        static/js/bootstrap.js on lines 3712..3718

                                                                        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 static/js/bootstrap.js and 5 other locations - About 1 hr to fix
                                                                        static/js/bootstrap.js on lines 1841..1847
                                                                        static/js/bootstrap.js on lines 3209..3215
                                                                        static/js/bootstrap.js on lines 3395..3401
                                                                        static/js/bootstrap.js on lines 3712..3718
                                                                        static/js/bootstrap.js on lines 3954..3960

                                                                        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 static/js/bootstrap.js and 5 other locations - About 1 hr to fix
                                                                        static/js/bootstrap.js on lines 1437..1443
                                                                        static/js/bootstrap.js on lines 3209..3215
                                                                        static/js/bootstrap.js on lines 3395..3401
                                                                        static/js/bootstrap.js on lines 3712..3718
                                                                        static/js/bootstrap.js on lines 3954..3960

                                                                        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 static/js/bootstrap.js and 5 other locations - About 1 hr to fix
                                                                        static/js/bootstrap.js on lines 1437..1443
                                                                        static/js/bootstrap.js on lines 1841..1847
                                                                        static/js/bootstrap.js on lines 3395..3401
                                                                        static/js/bootstrap.js on lines 3712..3718
                                                                        static/js/bootstrap.js on lines 3954..3960

                                                                        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 static/js/bootstrap.js and 5 other locations - About 1 hr to fix
                                                                        static/js/bootstrap.js on lines 1437..1443
                                                                        static/js/bootstrap.js on lines 1841..1847
                                                                        static/js/bootstrap.js on lines 3209..3215
                                                                        static/js/bootstrap.js on lines 3712..3718
                                                                        static/js/bootstrap.js on lines 3954..3960

                                                                        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 static/js/bootstrap.js and 5 other locations - About 1 hr to fix
                                                                        static/js/bootstrap.js on lines 1437..1443
                                                                        static/js/bootstrap.js on lines 1841..1847
                                                                        static/js/bootstrap.js on lines 3209..3215
                                                                        static/js/bootstrap.js on lines 3395..3401
                                                                        static/js/bootstrap.js on lines 3954..3960

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

                                                                            _createClass(Collapse, null, [{
                                                                              key: "VERSION",
                                                                              get: function get() {
                                                                                return VERSION$3;
                                                                              }
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 4 other locations - About 55 mins to fix
                                                                        static/js/bootstrap.js on lines 1094..1104
                                                                        static/js/bootstrap.js on lines 2531..2541
                                                                        static/js/bootstrap.js on lines 3722..3732
                                                                        static/js/bootstrap.js on lines 4180..4190

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

                                                                            _createClass(Modal, null, [{
                                                                              key: "VERSION",
                                                                              get: function get() {
                                                                                return VERSION$5;
                                                                              }
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 4 other locations - About 55 mins to fix
                                                                        static/js/bootstrap.js on lines 1094..1104
                                                                        static/js/bootstrap.js on lines 1447..1457
                                                                        static/js/bootstrap.js on lines 3722..3732
                                                                        static/js/bootstrap.js on lines 4180..4190

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

                                                                            _createClass(ScrollSpy, null, [{
                                                                              key: "VERSION",
                                                                              get: function get() {
                                                                                return VERSION$8;
                                                                              }
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 4 other locations - About 55 mins to fix
                                                                        static/js/bootstrap.js on lines 1094..1104
                                                                        static/js/bootstrap.js on lines 1447..1457
                                                                        static/js/bootstrap.js on lines 2531..2541
                                                                        static/js/bootstrap.js on lines 4180..4190

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

                                                                            _createClass(Toast, null, [{
                                                                              key: "VERSION",
                                                                              get: function get() {
                                                                                return VERSION$a;
                                                                              }
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 4 other locations - About 55 mins to fix
                                                                        static/js/bootstrap.js on lines 1094..1104
                                                                        static/js/bootstrap.js on lines 1447..1457
                                                                        static/js/bootstrap.js on lines 2531..2541
                                                                        static/js/bootstrap.js on lines 3722..3732

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

                                                                            _createClass(Carousel, null, [{
                                                                              key: "VERSION",
                                                                              get: function get() {
                                                                                return VERSION$2;
                                                                              }
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 4 other locations - About 55 mins to fix
                                                                        static/js/bootstrap.js on lines 1447..1457
                                                                        static/js/bootstrap.js on lines 2531..2541
                                                                        static/js/bootstrap.js on lines 3722..3732
                                                                        static/js/bootstrap.js on lines 4180..4190

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

                                                                          var ClassName$2 = {
                                                                            CAROUSEL: 'carousel',
                                                                            ACTIVE: 'active',
                                                                            SLIDE: 'slide',
                                                                            RIGHT: 'carousel-item-right',
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 1 other location - About 55 mins to fix
                                                                        static/js/bootstrap.js on lines 3492..3502

                                                                        Duplicated Code

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

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

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

                                                                        Tuning

                                                                        This issue has a mass of 53.

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

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

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

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

                                                                        Refactorings

                                                                        Further Reading

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

                                                                          var Selector$8 = {
                                                                            DATA_SPY: '[data-spy="scroll"]',
                                                                            ACTIVE: '.active',
                                                                            NAV_LIST_GROUP: '.nav, .list-group',
                                                                            NAV_LINKS: '.nav-link',
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 1 other location - About 55 mins to fix
                                                                        static/js/bootstrap.js on lines 597..607

                                                                        Duplicated Code

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

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

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

                                                                        Tuning

                                                                        This issue has a mass of 53.

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

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

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

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

                                                                        Refactorings

                                                                        Further Reading

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

                                                                            _proto._getConfig = function _getConfig(config) {
                                                                              config = _objectSpread({}, Default, config);
                                                                              Util.typeCheckConfig(NAME$2, config, DefaultType);
                                                                              return config;
                                                                            };
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 1 other location - About 50 mins to fix
                                                                        static/js/bootstrap.js on lines 2224..2228

                                                                        Duplicated Code

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

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

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

                                                                        Tuning

                                                                        This issue has a mass of 51.

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

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

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

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

                                                                        Refactorings

                                                                        Further Reading

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

                                                                            _proto._getConfig = function _getConfig(config) {
                                                                              config = _objectSpread({}, Default$3, config);
                                                                              Util.typeCheckConfig(NAME$5, config, DefaultType$3);
                                                                              return config;
                                                                            };
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 1 other location - About 50 mins to fix
                                                                        static/js/bootstrap.js on lines 746..750

                                                                        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) {
                                                                                $(document.body).children().off('mouseover', null, $.noop);
                                                                              }
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 1 other location - About 45 mins to fix
                                                                        static/js/bootstrap.js on lines 1893..1895

                                                                        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) {
                                                                                  $(document.body).children().off('mouseover', null, $.noop);
                                                                                }
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 1 other location - About 45 mins to fix
                                                                        static/js/bootstrap.js on lines 2917..2919

                                                                        Duplicated Code

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

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

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

                                                                        Tuning

                                                                        This issue has a mass of 50.

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

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

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

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

                                                                        Refactorings

                                                                        Further Reading

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

                                                                            _proto.addAttachmentClass = function addAttachmentClass(attachment) {
                                                                              $(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
                                                                            };
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 1 other location - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 3341..3343

                                                                        Duplicated Code

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

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

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

                                                                        Tuning

                                                                        This issue has a mass of 49.

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

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

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

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

                                                                        Refactorings

                                                                        Further Reading

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

                                                                            _proto.addAttachmentClass = function addAttachmentClass(attachment) {
                                                                              $(this.getTipElement()).addClass(CLASS_PREFIX$1 + "-" + attachment);
                                                                            };
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 1 other location - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 2946..2948

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

                                                                          $.fn[NAME].noConflict = function () {
                                                                            $.fn[NAME] = JQUERY_NO_CONFLICT;
                                                                            return Alert._jQueryInterface;
                                                                          };
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 10 other locations - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 536..539
                                                                        static/js/bootstrap.js on lines 1134..1137
                                                                        static/js/bootstrap.js on lines 1494..1497
                                                                        static/js/bootstrap.js on lines 2016..2019
                                                                        static/js/bootstrap.js on lines 2592..2595
                                                                        static/js/bootstrap.js on lines 3268..3271
                                                                        static/js/bootstrap.js on lines 3455..3458
                                                                        static/js/bootstrap.js on lines 3762..3765
                                                                        static/js/bootstrap.js on lines 3994..3997
                                                                        static/js/bootstrap.js on lines 4204..4207

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

                                                                          $.fn[NAME$6].noConflict = function () {
                                                                            $.fn[NAME$6] = JQUERY_NO_CONFLICT$6;
                                                                            return Tooltip._jQueryInterface;
                                                                          };
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 10 other locations - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 382..385
                                                                        static/js/bootstrap.js on lines 536..539
                                                                        static/js/bootstrap.js on lines 1134..1137
                                                                        static/js/bootstrap.js on lines 1494..1497
                                                                        static/js/bootstrap.js on lines 2016..2019
                                                                        static/js/bootstrap.js on lines 2592..2595
                                                                        static/js/bootstrap.js on lines 3455..3458
                                                                        static/js/bootstrap.js on lines 3762..3765
                                                                        static/js/bootstrap.js on lines 3994..3997
                                                                        static/js/bootstrap.js on lines 4204..4207

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

                                                                          $.fn[NAME$2].noConflict = function () {
                                                                            $.fn[NAME$2] = JQUERY_NO_CONFLICT$2;
                                                                            return Carousel._jQueryInterface;
                                                                          };
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 10 other locations - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 382..385
                                                                        static/js/bootstrap.js on lines 536..539
                                                                        static/js/bootstrap.js on lines 1494..1497
                                                                        static/js/bootstrap.js on lines 2016..2019
                                                                        static/js/bootstrap.js on lines 2592..2595
                                                                        static/js/bootstrap.js on lines 3268..3271
                                                                        static/js/bootstrap.js on lines 3455..3458
                                                                        static/js/bootstrap.js on lines 3762..3765
                                                                        static/js/bootstrap.js on lines 3994..3997
                                                                        static/js/bootstrap.js on lines 4204..4207

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

                                                                          $.fn[NAME$7].noConflict = function () {
                                                                            $.fn[NAME$7] = JQUERY_NO_CONFLICT$7;
                                                                            return Popover._jQueryInterface;
                                                                          };
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 10 other locations - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 382..385
                                                                        static/js/bootstrap.js on lines 536..539
                                                                        static/js/bootstrap.js on lines 1134..1137
                                                                        static/js/bootstrap.js on lines 1494..1497
                                                                        static/js/bootstrap.js on lines 2016..2019
                                                                        static/js/bootstrap.js on lines 2592..2595
                                                                        static/js/bootstrap.js on lines 3268..3271
                                                                        static/js/bootstrap.js on lines 3762..3765
                                                                        static/js/bootstrap.js on lines 3994..3997
                                                                        static/js/bootstrap.js on lines 4204..4207

                                                                        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 Selector$2 = {
                                                                            ACTIVE: '.active',
                                                                            ACTIVE_ITEM: '.active.carousel-item',
                                                                            ITEM: '.carousel-item',
                                                                            ITEM_IMG: '.carousel-item img',
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 2 other locations - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 1534..1543
                                                                        static/js/bootstrap.js on lines 1551..1560

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

                                                                          $.fn[NAME$5].noConflict = function () {
                                                                            $.fn[NAME$5] = JQUERY_NO_CONFLICT$5;
                                                                            return Modal._jQueryInterface;
                                                                          };
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 10 other locations - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 382..385
                                                                        static/js/bootstrap.js on lines 536..539
                                                                        static/js/bootstrap.js on lines 1134..1137
                                                                        static/js/bootstrap.js on lines 1494..1497
                                                                        static/js/bootstrap.js on lines 2016..2019
                                                                        static/js/bootstrap.js on lines 3268..3271
                                                                        static/js/bootstrap.js on lines 3455..3458
                                                                        static/js/bootstrap.js on lines 3762..3765
                                                                        static/js/bootstrap.js on lines 3994..3997
                                                                        static/js/bootstrap.js on lines 4204..4207

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

                                                                          $.fn[NAME$1].noConflict = function () {
                                                                            $.fn[NAME$1] = JQUERY_NO_CONFLICT$1;
                                                                            return Button._jQueryInterface;
                                                                          };
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 10 other locations - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 382..385
                                                                        static/js/bootstrap.js on lines 1134..1137
                                                                        static/js/bootstrap.js on lines 1494..1497
                                                                        static/js/bootstrap.js on lines 2016..2019
                                                                        static/js/bootstrap.js on lines 2592..2595
                                                                        static/js/bootstrap.js on lines 3268..3271
                                                                        static/js/bootstrap.js on lines 3455..3458
                                                                        static/js/bootstrap.js on lines 3762..3765
                                                                        static/js/bootstrap.js on lines 3994..3997
                                                                        static/js/bootstrap.js on lines 4204..4207

                                                                        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$4 = {
                                                                            DISABLED: 'disabled',
                                                                            SHOW: 'show',
                                                                            DROPUP: 'dropup',
                                                                            DROPRIGHT: 'dropright',
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 2 other locations - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 608..617
                                                                        static/js/bootstrap.js on lines 1551..1560

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

                                                                          $.fn[NAME$4].noConflict = function () {
                                                                            $.fn[NAME$4] = JQUERY_NO_CONFLICT$4;
                                                                            return Dropdown._jQueryInterface;
                                                                          };
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 10 other locations - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 382..385
                                                                        static/js/bootstrap.js on lines 536..539
                                                                        static/js/bootstrap.js on lines 1134..1137
                                                                        static/js/bootstrap.js on lines 1494..1497
                                                                        static/js/bootstrap.js on lines 2592..2595
                                                                        static/js/bootstrap.js on lines 3268..3271
                                                                        static/js/bootstrap.js on lines 3455..3458
                                                                        static/js/bootstrap.js on lines 3762..3765
                                                                        static/js/bootstrap.js on lines 3994..3997
                                                                        static/js/bootstrap.js on lines 4204..4207

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

                                                                          $.fn[NAME$8].noConflict = function () {
                                                                            $.fn[NAME$8] = JQUERY_NO_CONFLICT$8;
                                                                            return ScrollSpy._jQueryInterface;
                                                                          };
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 10 other locations - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 382..385
                                                                        static/js/bootstrap.js on lines 536..539
                                                                        static/js/bootstrap.js on lines 1134..1137
                                                                        static/js/bootstrap.js on lines 1494..1497
                                                                        static/js/bootstrap.js on lines 2016..2019
                                                                        static/js/bootstrap.js on lines 2592..2595
                                                                        static/js/bootstrap.js on lines 3268..3271
                                                                        static/js/bootstrap.js on lines 3455..3458
                                                                        static/js/bootstrap.js on lines 3994..3997
                                                                        static/js/bootstrap.js on lines 4204..4207

                                                                        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 static/js/bootstrap.js and 2 other locations - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 608..617
                                                                        static/js/bootstrap.js on lines 1534..1543

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

                                                                          $.fn[NAME$3].noConflict = function () {
                                                                            $.fn[NAME$3] = JQUERY_NO_CONFLICT$3;
                                                                            return Collapse._jQueryInterface;
                                                                          };
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 10 other locations - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 382..385
                                                                        static/js/bootstrap.js on lines 536..539
                                                                        static/js/bootstrap.js on lines 1134..1137
                                                                        static/js/bootstrap.js on lines 2016..2019
                                                                        static/js/bootstrap.js on lines 2592..2595
                                                                        static/js/bootstrap.js on lines 3268..3271
                                                                        static/js/bootstrap.js on lines 3455..3458
                                                                        static/js/bootstrap.js on lines 3762..3765
                                                                        static/js/bootstrap.js on lines 3994..3997
                                                                        static/js/bootstrap.js on lines 4204..4207

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

                                                                          $.fn[NAME$a].noConflict = function () {
                                                                            $.fn[NAME$a] = JQUERY_NO_CONFLICT$a;
                                                                            return Toast._jQueryInterface;
                                                                          };
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 10 other locations - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 382..385
                                                                        static/js/bootstrap.js on lines 536..539
                                                                        static/js/bootstrap.js on lines 1134..1137
                                                                        static/js/bootstrap.js on lines 1494..1497
                                                                        static/js/bootstrap.js on lines 2016..2019
                                                                        static/js/bootstrap.js on lines 2592..2595
                                                                        static/js/bootstrap.js on lines 3268..3271
                                                                        static/js/bootstrap.js on lines 3455..3458
                                                                        static/js/bootstrap.js on lines 3762..3765
                                                                        static/js/bootstrap.js on lines 3994..3997

                                                                        Duplicated Code

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

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

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

                                                                        Tuning

                                                                        This issue has a mass of 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 11 locations. Consider refactoring.
                                                                        Open

                                                                          $.fn[NAME$9].noConflict = function () {
                                                                            $.fn[NAME$9] = JQUERY_NO_CONFLICT$9;
                                                                            return Tab._jQueryInterface;
                                                                          };
                                                                        Severity: Major
                                                                        Found in static/js/bootstrap.js and 10 other locations - About 40 mins to fix
                                                                        static/js/bootstrap.js on lines 382..385
                                                                        static/js/bootstrap.js on lines 536..539
                                                                        static/js/bootstrap.js on lines 1134..1137
                                                                        static/js/bootstrap.js on lines 1494..1497
                                                                        static/js/bootstrap.js on lines 2016..2019
                                                                        static/js/bootstrap.js on lines 2592..2595
                                                                        static/js/bootstrap.js on lines 3268..3271
                                                                        static/js/bootstrap.js on lines 3455..3458
                                                                        static/js/bootstrap.js on lines 3762..3765
                                                                        static/js/bootstrap.js on lines 4204..4207

                                                                        Duplicated Code

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

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

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

                                                                        Tuning

                                                                        This issue has a mass of 48.

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

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

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

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

                                                                        Refactorings

                                                                        Further Reading

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

                                                                            _proto.dispose = function dispose() {
                                                                              $.removeData(this._element, DATA_KEY$1);
                                                                              this._element = null;
                                                                            }; // Static
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 2 other locations - About 35 mins to fix
                                                                        static/js/bootstrap.js on lines 281..284
                                                                        static/js/bootstrap.js on lines 3879..3882

                                                                        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() {
                                                                              $.removeData(this._element, DATA_KEY);
                                                                              this._element = null;
                                                                            }; // Private
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 2 other locations - About 35 mins to fix
                                                                        static/js/bootstrap.js on lines 477..480
                                                                        static/js/bootstrap.js on lines 3879..3882

                                                                        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

                                                                                $(_this2._element).removeClass(ClassName$3.COLLAPSING).addClass(ClassName$3.COLLAPSE).trigger(Event$3.HIDDEN);
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 1 other location - About 35 mins to fix
                                                                        static/js/bootstrap.js on lines 1293..1293

                                                                        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

                                                                                $(_this._element).removeClass(ClassName$3.COLLAPSING).addClass(ClassName$3.COLLAPSE).addClass(ClassName$3.SHOW);
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 1 other location - About 35 mins to fix
                                                                        static/js/bootstrap.js on lines 1349..1349

                                                                        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() {
                                                                              $.removeData(this._element, DATA_KEY$9);
                                                                              this._element = null;
                                                                            }; // Private
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 2 other locations - About 35 mins to fix
                                                                        static/js/bootstrap.js on lines 281..284
                                                                        static/js/bootstrap.js on lines 477..480

                                                                        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 (!context.config.delay || !context.config.delay.hide) {
                                                                                context.hide();
                                                                                return;
                                                                              }
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 1 other location - About 35 mins to fix
                                                                        static/js/bootstrap.js on lines 3070..3073

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

                                                                        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.prev = function prev() {
                                                                              if (!this._isSliding) {
                                                                                this._slide(Direction.PREV);
                                                                              }
                                                                            };
                                                                        Severity: Minor
                                                                        Found in static/js/bootstrap.js and 1 other location - About 30 mins to fix
                                                                        static/js/bootstrap.js on lines 654..658

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

                                                                        Duplicated Code

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

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

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

                                                                        Tuning

                                                                        This issue has a mass of 45.

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

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

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

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

                                                                        Refactorings

                                                                        Further Reading

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

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

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

                                                                        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