fnando/babel-schmooze-sprockets

View on GitHub

Showing 215 of 215 total issues

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

},{"105":105,"107":107,"108":108}],12:[function(_dereq_,module,exports){
// 0 -> Array#forEach
// 1 -> Array#map
// 2 -> Array#filter
// 3 -> Array#some
Severity: Minor
Found in app/assets/javascripts/babel/polyfill.js - About 1 hr to fix

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

    },{"73":73,"76":76,"77":77}],32:[function(_dereq_,module,exports){
    var global    = _dereq_(38)
      , core      = _dereq_(23)
      , hide      = _dereq_(40)
      , redefine  = _dereq_(87)
    Severity: Minor
    Found in app/assets/javascripts/babel/polyfill.js - About 1 hr to fix

      Function 79 has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
      Open

      },{"23":23,"32":32,"34":34}],79:[function(_dereq_,module,exports){
      var getKeys   = _dereq_(76)
        , toIObject = _dereq_(107)
        , isEnum    = _dereq_(77).f;
      module.exports = function(isEntries){
      Severity: Minor
      Found in app/assets/javascripts/babel/polyfill.js - About 1 hr 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 jsx has 34 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      babelHelpers.jsx = function () {
        var REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for && Symbol.for("react.element") || 0xeac7;
        return function createRawReactElement(type, props, key, children) {
          var defaultProps = type && type.defaultProps;
          var childrenLength = arguments.length - 3;
      Severity: Minor
      Found in app/assets/javascripts/babel/external-helpers.js - About 1 hr to fix

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

        },{"12":12,"32":32,"96":96}],128:[function(_dereq_,module,exports){
        'use strict';
        var ctx            = _dereq_(25)
          , $export        = _dereq_(32)
          , toObject       = _dereq_(109)
        Severity: Minor
        Found in app/assets/javascripts/babel/polyfill.js - About 1 hr to fix

          Function 70 has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
          Open

          },{"34":34,"38":38,"58":58}],70:[function(_dereq_,module,exports){
          var pIE            = _dereq_(77)
            , createDesc     = _dereq_(85)
            , toIObject      = _dereq_(107)
            , toPrimitive    = _dereq_(110)
          Severity: Minor
          Found in app/assets/javascripts/babel/polyfill.js - About 1 hr 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 75 has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
          Open

          },{"109":109,"39":39,"93":93}],75:[function(_dereq_,module,exports){
          var has          = _dereq_(39)
            , toIObject    = _dereq_(107)
            , arrayIndexOf = _dereq_(11)(false)
            , IE_PROTO     = _dereq_(93)('IE_PROTO');
          Severity: Minor
          Found in app/assets/javascripts/babel/polyfill.js - About 1 hr 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 201 has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
          Open

          },{"3":3,"32":32,"7":7}],201:[function(_dereq_,module,exports){
          // 26.1.2 Reflect.construct(target, argumentsList [, newTarget])
          var $export   = _dereq_(32)
            , create    = _dereq_(66)
            , aFunction = _dereq_(3)
          Severity: Minor
          Found in app/assets/javascripts/babel/polyfill.js - About 1 hr 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 90 has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
          Open

          },{}],90:[function(_dereq_,module,exports){
          // Works with __proto__ only. Old v8 can't work with null proto objects.
          /* eslint-disable no-proto */
          var isObject = _dereq_(49)
            , anObject = _dereq_(7);
          Severity: Minor
          Found in app/assets/javascripts/babel/polyfill.js - About 1 hr 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 slicedToArray has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
          Open

          babelHelpers.slicedToArray = function () {
            function sliceIterator(arr, i) {
              var _arr = [];
              var _n = true;
              var _d = false;
          Severity: Minor
          Found in app/assets/javascripts/babel/external-helpers.js - About 1 hr 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 interopRequireWildcard has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
          Open

          babelHelpers.interopRequireWildcard = function (obj) {
            if (obj && obj.__esModule) {
              return obj;
            } else {
              var newObj = {};
          Severity: Minor
          Found in app/assets/javascripts/babel/external-helpers.js - About 1 hr 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 201 has 31 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          },{"3":3,"32":32,"7":7}],201:[function(_dereq_,module,exports){
          // 26.1.2 Reflect.construct(target, argumentsList [, newTarget])
          var $export   = _dereq_(32)
            , create    = _dereq_(66)
            , aFunction = _dereq_(3)
          Severity: Minor
          Found in app/assets/javascripts/babel/polyfill.js - About 1 hr to fix

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

            },{"109":109,"34":34,"45":45,"73":73,"76":76,"77":77}],66:[function(_dereq_,module,exports){
            // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
            var anObject    = _dereq_(7)
              , dPs         = _dereq_(68)
              , enumBugKeys = _dereq_(30)
            Severity: Minor
            Found in app/assets/javascripts/babel/polyfill.js - About 1 hr to fix

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

              babelHelpers.slicedToArray = function () {
                function sliceIterator(arr, i) {
                  var _arr = [];
                  var _n = true;
                  var _d = false;
              Severity: Minor
              Found in app/assets/javascripts/babel/external-helpers.js - About 1 hr to fix

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

                  return function createRawReactElement(type, props, key, children) {
                    var defaultProps = type && type.defaultProps;
                    var childrenLength = arguments.length - 3;
                
                    if (!props && childrenLength !== 0) {
                Severity: Minor
                Found in app/assets/javascripts/babel/external-helpers.js - About 1 hr to fix

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

                  module.exports = function(TYPE, $create){
                    var IS_MAP        = TYPE == 1
                      , IS_FILTER     = TYPE == 2
                      , IS_SOME       = TYPE == 3
                      , IS_EVERY      = TYPE == 4
                  Severity: Minor
                  Found in app/assets/javascripts/babel/polyfill.js - About 1 hr to fix

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

                    },{"87":87}],87:[function(_dereq_,module,exports){
                    var global    = _dereq_(38)
                      , hide      = _dereq_(40)
                      , has       = _dereq_(39)
                      , SRC       = _dereq_(114)('src')
                    Severity: Minor
                    Found in app/assets/javascripts/babel/polyfill.js - About 1 hr to fix

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

                      },{"104":104,"18":18,"38":38}],65:[function(_dereq_,module,exports){
                      'use strict';
                      // 19.1.2.1 Object.assign(target, source, ...)
                      var getKeys  = _dereq_(76)
                        , gOPS     = _dereq_(73)
                      Severity: Minor
                      Found in app/assets/javascripts/babel/polyfill.js - About 1 hr to fix

                        Function 59 has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                        Open

                        },{}],59:[function(_dereq_,module,exports){
                        // 20.2.2.14 Math.expm1(x)
                        var $expm1 = Math.expm1;
                        module.exports = (!$expm1
                          // Old FF bug
                        Severity: Minor
                        Found in app/assets/javascripts/babel/polyfill.js - About 1 hr 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 get has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                        Open

                        babelHelpers.get = function get(object, property, receiver) {
                          if (object === null) object = Function.prototype;
                          var desc = Object.getOwnPropertyDescriptor(object, property);
                        
                          if (desc === undefined) {
                        Severity: Minor
                        Found in app/assets/javascripts/babel/external-helpers.js - About 1 hr 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