Sign upLogin

lexmihaylov/AsyncUtils

View on GitHub
Star
src/Loop.js

Summary

Maintainability
B
4 hrs
Test Coverage

Function Loop has 71 lines of code (exceeds 25 allowed). Consider refactoring.
Open

var Loop = (function() {
    /**
     * Async loop class that takes a handle as a parameter and a maximum number of iterations
     * @constructor
     * @param {Function} handle
Severity: Major
Found in src/Loop.js - About 2 hrs to fix

    Function Loop has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
    Open

    var Loop = (function() {
    /**
     * Async loop class that takes a handle as a parameter and a maximum number of iterations
     * @constructor
     * @param {Function} handle
    Severity: Minor
    Found in src/Loop.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

    unnecessary '.call()'.
    Open

                if(this.handle.call(this)){
    Severity: Minor
    Found in src/Loop.js by eslint

    Disallow unnecessary .call() and .apply(). (no-useless-call)

    The function invocation can be written by Function.prototype.call() and Function.prototype.apply(). But Function.prototype.call() and Function.prototype.apply() are slower than the normal function invocation.

    Rule Details

    This rule is aimed to flag usage of Function.prototype.call() and Function.prototype.apply() that can be replaced with the normal function invocation.

    Examples of incorrect code for this rule:

    /*eslint no-useless-call: "error"*/

// These are same as `foo(1, 2, 3);`
foo.call(undefined, 1, 2, 3);
foo.apply(undefined, [1, 2, 3]);
foo.call(null, 1, 2, 3);
foo.apply(null, [1, 2, 3]);

// These are same as `obj.foo(1, 2, 3);`
obj.foo.call(obj, 1, 2, 3);
obj.foo.apply(obj, [1, 2, 3]);

    Examples of correct code for this rule:

    /*eslint no-useless-call: "error"*/

// The `this` binding is different.
foo.call(obj, 1, 2, 3);
foo.apply(obj, [1, 2, 3]);
obj.foo.call(null, 1, 2, 3);
obj.foo.apply(null, [1, 2, 3]);
obj.foo.call(otherObj, 1, 2, 3);
obj.foo.apply(otherObj, [1, 2, 3]);

// The argument list is variadic.
foo.apply(undefined, args);
foo.apply(null, args);
obj.foo.apply(obj, args);

    Known Limitations

    This rule compares code statically to check whether or not thisArg is changed. So if the code about thisArg is a dynamic expression, this rule cannot judge correctly.

    Examples of incorrect code for this rule:

    /*eslint no-useless-call: "error"*/

a[i++].foo.call(a[i++], 1, 2, 3);

    Examples of correct code for this rule:

    /*eslint no-useless-call: "error"*/

a[++i].foo.call(a[i], 1, 2, 3);

    When Not To Use It

    If you don't want to be notified about unnecessary .call() and .apply(), you can safely disable this rule. Source: http://eslint.org/docs/rules/

    There are no issues that match your filters.

    Category
    Status