Dragoniasty/NewsWorldFront

View on GitHub

Showing 1,097 of 1,772 total issues

Function Swiper has 2516 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    var Swiper = function (container, params) {
        if (!(this instanceof Swiper)) return new Swiper(container, params);

        var defaults = {
            direction: 'horizontal',
Severity: Major
Found in src/bower_components/swiper/dist/js/swiper.jquery.js - About 1 wk to fix

    Function Swiper has 2516 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        var Swiper = function (container, params) {
            if (!(this instanceof Swiper)) return new Swiper(container, params);
    
            var defaults = {
                direction: 'horizontal',
    Severity: Major
    Found in src/bower_components/swiper/dist/js/swiper.js - About 1 wk to fix

      Function Dom7 has a Cognitive Complexity of 521 (exceeds 5 allowed). Consider refactoring.
      Open

      var Dom7 = (function () {
          var Dom7 = function (arr) {
              var _this = this, i = 0;
              // Create array-like object
              for (i = 0; i < arr.length; i++) {
      Severity: Minor
      Found in src/bower_components/swiper/src/js/dom.js - About 1 wk to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      File core.js has 3532 lines of code (exceeds 250 allowed). Consider refactoring.
      Open

      /*!
       * Angular Material Design
       * https://github.com/angular/material
       * @license MIT
       * v1.0.7
      Severity: Major
      Found in src/bower_components/angular-material/modules/js/core/core.js - About 1 wk to fix

        File core.js has 3529 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        /*!
         * Angular Material Design
         * https://github.com/angular/material
         * @license MIT
         * v1.0.7
        Severity: Major
        Found in src/bower_components/angular-material/modules/closure/core/core.js - About 1 wk to fix

          File swiper.js has 3259 lines of code (exceeds 250 allowed). Consider refactoring.
          Open

          /**
           * Swiper 3.0.8
           * Most modern mobile touch slider and framework with hardware accelerated transitions
           * 
           * http://www.idangero.us/swiper/
          Severity: Major
          Found in src/bower_components/swiper/dist/js/swiper.js - About 1 wk to fix

            File swiper.jquery.js has 2642 lines of code (exceeds 250 allowed). Consider refactoring.
            Open

            /**
             * Swiper 3.0.8
             * Most modern mobile touch slider and framework with hardware accelerated transitions
             * 
             * http://www.idangero.us/swiper/
            Severity: Major
            Found in src/bower_components/swiper/dist/js/swiper.jquery.js - About 1 wk to fix

              Function $StateProvider has a Cognitive Complexity of 304 (exceeds 5 allowed). Consider refactoring.
              Open

              function $StateProvider(   $urlRouterProvider,   $urlMatcherFactory) {
              
                var root, states = {}, $state, queue = {}, abstractKey = 'abstract';
              
                // Builds state properties from definition passed to registerState()
              Severity: Minor
              Found in src/bower_components/angular-ui-router/src/state.js - About 6 days to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              File angular-animate.js has 2185 lines of code (exceeds 250 allowed). Consider refactoring.
              Open

              /**
               * @license AngularJS v1.5.3
               * (c) 2010-2016 Google, Inc. http://angularjs.org
               * License: MIT
               */
              Severity: Major
              Found in src/bower_components/angular-animate/angular-animate.js - About 6 days to fix

                File angular-ui-router.js has 1808 lines of code (exceeds 250 allowed). Consider refactoring.
                Open

                /**
                 * State-based routing for AngularJS
                 * @version v0.2.18
                 * @link http://angular-ui.github.com/
                 * @license MIT License, http://www.opensource.org/licenses/MIT
                Severity: Major
                Found in src/bower_components/angular-ui-router/release/angular-ui-router.js - About 4 days to fix

                  File core.js has 1614 lines of code (exceeds 250 allowed). Consider refactoring.
                  Open

                  var defaults = {
                      direction: 'horizontal',
                      touchEventsTarget: 'container',
                      initialSlide: 0,
                      speed: 300,
                  Severity: Major
                  Found in src/bower_components/swiper/src/js/core.js - About 4 days to fix

                    Function MenuProvider has a Cognitive Complexity of 192 (exceeds 5 allowed). Consider refactoring.
                    Open

                    function MenuProvider($$interimElementProvider) {
                      var MENU_EDGE_MARGIN = 8;
                    
                      menuDefaultOptions.$inject = ["$mdUtil", "$mdTheming", "$mdConstant", "$document", "$window", "$q", "$$rAF", "$animateCss", "$animate"];
                      return $$interimElementProvider('$mdMenu')
                    Severity: Minor
                    Found in src/bower_components/angular-material/modules/closure/menu/menu.js - About 3 days to fix

                    Cognitive Complexity

                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                    A method's cognitive complexity is based on a few simple rules:

                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                    • Code is considered more complex for each "break in the linear flow of the code"
                    • Code is considered more complex when "flow breaking structures are nested"

                    Further reading

                    Function SelectProvider has a Cognitive Complexity of 188 (exceeds 5 allowed). Consider refactoring.
                    Open

                    function SelectProvider($$interimElementProvider) {
                      selectDefaultOptions.$inject = ["$mdSelect", "$mdConstant", "$mdUtil", "$window", "$q", "$$rAF", "$animateCss", "$animate", "$document"];
                      return $$interimElementProvider('$mdSelect')
                        .setDefaults({
                          methods: ['target'],
                    Severity: Minor
                    Found in src/bower_components/angular-material/modules/closure/select/select.js - About 3 days to fix

                    Cognitive Complexity

                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                    A method's cognitive complexity is based on a few simple rules:

                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                    • Code is considered more complex for each "break in the linear flow of the code"
                    • Code is considered more complex when "flow breaking structures are nested"

                    Further reading

                    Function MdDialogProvider has a Cognitive Complexity of 176 (exceeds 5 allowed). Consider refactoring.
                    Open

                    function MdDialogProvider($$interimElementProvider) {
                      // Elements to capture and redirect focus when the user presses tab at the dialog boundary.
                      var topFocusTrap, bottomFocusTrap;
                    
                        advancedDialogOptions.$inject = ["$mdDialog", "$mdTheming", "$mdConstant"];
                    Severity: Minor
                    Found in src/bower_components/angular-material/modules/closure/dialog/dialog.js - About 3 days to fix

                    Cognitive Complexity

                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                    A method's cognitive complexity is based on a few simple rules:

                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                    • Code is considered more complex for each "break in the linear flow of the code"
                    • Code is considered more complex when "flow breaking structures are nested"

                    Further reading

                    Function UtilFactory has a Cognitive Complexity of 161 (exceeds 5 allowed). Consider refactoring.
                    Open

                    function UtilFactory($document, $timeout, $compile, $rootScope, $$mdAnimate, $interpolate, $log, $rootElement, $window) {
                      // Setup some core variables for the processTemplate method
                      var startSymbol = $interpolate.startSymbol(),
                        endSymbol = $interpolate.endSymbol(),
                        usesStandardSymbols = ((startSymbol === '{{') && (endSymbol === '}}'));
                    Severity: Minor
                    Found in src/bower_components/angular-material/modules/closure/core/core.js - About 3 days to fix

                    Cognitive Complexity

                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                    A method's cognitive complexity is based on a few simple rules:

                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                    • Code is considered more complex for each "break in the linear flow of the code"
                    • Code is considered more complex when "flow breaking structures are nested"

                    Further reading

                    Function Dom7 has 615 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                        var Dom7 = (function () {
                            var Dom7 = function (arr) {
                                var _this = this, i = 0;
                                // Create array-like object
                                for (i = 0; i < arr.length; i++) {
                    Severity: Major
                    Found in src/bower_components/swiper/dist/js/swiper.js - About 3 days to fix

                      Function Dom7 has 615 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      var Dom7 = (function () {
                          var Dom7 = function (arr) {
                              var _this = this, i = 0;
                              // Create array-like object
                              for (i = 0; i < arr.length; i++) {
                      Severity: Major
                      Found in src/bower_components/swiper/src/js/dom.js - About 3 days to fix

                        File angular-mocks.js has 1179 lines of code (exceeds 250 allowed). Consider refactoring.
                        Open

                        /**
                         * @license AngularJS v1.5.3
                         * (c) 2010-2016 Google, Inc. http://angularjs.org
                         * License: MIT
                         */
                        Severity: Major
                        Found in src/bower_components/angular-mocks/angular-mocks.js - About 3 days to fix

                          Function MdAutocompleteCtrl has a Cognitive Complexity of 146 (exceeds 5 allowed). Consider refactoring.
                          Open

                          function MdAutocompleteCtrl ($scope, $element, $mdUtil, $mdConstant, $mdTheming, $window,
                                                       $animate, $rootElement, $attrs, $q) {
                            //-- private variables
                            var ctrl                 = this,
                                itemParts            = $scope.itemsExpr.split(/ in /i),

                          Cognitive Complexity

                          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                          A method's cognitive complexity is based on a few simple rules:

                          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                          • Code is considered more complex for each "break in the linear flow of the code"
                          • Code is considered more complex when "flow breaking structures are nested"

                          Further reading

                          Function onTouchEnd has a Cognitive Complexity of 142 (exceeds 5 allowed). Consider refactoring.
                          Open

                          s.onTouchEnd = function (e) {
                              if (e.originalEvent) e = e.originalEvent;
                              s.emit('onTouchEnd', s, e);
                              if (!isTouched) return;
                              //Return Grab Cursor
                          Severity: Minor
                          Found in src/bower_components/swiper/src/js/core.js - About 2 days to fix

                          Cognitive Complexity

                          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                          A method's cognitive complexity is based on a few simple rules:

                          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                          • Code is considered more complex for each "break in the linear flow of the code"
                          • Code is considered more complex when "flow breaking structures are nested"

                          Further reading

                          Severity
                          Category
                          Status
                          Source
                          Language