elevenetc/device-manager-back-end

View on GitHub
src/view/view-slack.js

Summary

Maintainability
A
2 hrs
Test Coverage

Function 'render' has too many statements (39). Maximum allowed is 30.
Open

function render(devices, verbose, filters) {
Severity: Minor
Found in src/view/view-slack.js by eslint

enforce a maximum number of statements allowed in function blocks (max-statements)

The max-statements rule allows you to specify the maximum number of statements allowed in a function.

function foo() {
  var bar = 1; // one statement
  var baz = 2; // two statements
  var qux = 3; // three statements
}

Rule Details

This rule enforces a maximum number of statements allowed in function blocks.

Options

This rule has a number or object option:

  • "max" (default 10) enforces a maximum number of statements allows in function blocks

Deprecated: The object property maximum is deprecated; please use the object property max instead.

This rule has an object option:

  • "ignoreTopLevelFunctions": true ignores top-level functions

max

Examples of incorrect code for this rule with the default { "max": 10 } option:

/*eslint max-statements: ["error", 10]*/
/*eslint-env es6*/

function foo() {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;

  var foo11 = 11; // Too many.
}

let foo = () => {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;

  var foo11 = 11; // Too many.
};

Examples of correct code for this rule with the default { "max": 10 } option:

/*eslint max-statements: ["error", 10]*/
/*eslint-env es6*/

function foo() {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;
  return function () {

    // The number of statements in the inner function does not count toward the
    // statement maximum.

    return 42;
  };
}

let foo = () => {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;
  return function () {

    // The number of statements in the inner function does not count toward the
    // statement maximum.

    return 42;
  };
}

ignoreTopLevelFunctions

Examples of additional correct code for this rule with the { "max": 10 }, { "ignoreTopLevelFunctions": true } options:

/*eslint max-statements: ["error", 10, { "ignoreTopLevelFunctions": true }]*/

function foo() {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;
  var foo11 = 11;
}

Related Rules

  • [complexity](complexity.md)
  • [max-depth](max-depth.md)
  • [max-len](max-len.md)
  • [max-nested-callbacks](max-nested-callbacks.md)
  • [max-params](max-params.md) Source: http://eslint.org/docs/rules/

Function render has 48 lines of code (exceeds 25 allowed). Consider refactoring.
Open

function render(devices, verbose, filters) {

    let map = new OrderedMap();
    let result = '';
    if(utils.isDefined(filters) && '' !== filters) result = 'Filters: `' + filters + '`, ';
Severity: Minor
Found in src/view/view-slack.js - About 1 hr to fix

    Function render has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
    Open

    function render(devices, verbose, filters) {
    
        let map = new OrderedMap();
        let result = '';
        if(utils.isDefined(filters) && '' !== filters) result = 'Filters: `' + filters + '`, ';
    Severity: Minor
    Found in src/view/view-slack.js - About 55 mins 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

    Don't make functions within a loop.
    Open

                map.iterate(function (key, value) {
    Severity: Minor
    Found in src/view/view-slack.js by eslint

    Disallow Functions in Loops (no-loop-func)

    Writing functions within loops tends to result in errors due to the way the function creates a closure around the loop. For example:

    for (var i = 0; i < 10; i++) {
        funcs[i] = function() {
            return i;
        };
    }

    In this case, you would expect each function created within the loop to return a different number. In reality, each function returns 10, because that was the last value of i in the scope.

    let or const mitigate this problem.

    /*eslint-env es6*/
    
    for (let i = 0; i < 10; i++) {
        funcs[i] = function() {
            return i;
        };
    }

    In this case, each function created within the loop returns a different number as expected.

    Rule Details

    This error is raised to highlight a piece of code that may not work as you expect it to and could also indicate a misunderstanding of how the language works. Your code may run without any problems if you do not fix this error, but in some situations it could behave unexpectedly.

    Examples of incorrect code for this rule:

    /*eslint no-loop-func: "error"*/
    /*eslint-env es6*/
    
    for (var i=10; i; i--) {
        (function() { return i; })();
    }
    
    while(i) {
        var a = function() { return i; };
        a();
    }
    
    do {
        function a() { return i; };
        a();
    } while (i);
    
    let foo = 0;
    for (let i=10; i; i--) {
        // Bad, function is referencing block scoped variable in the outer scope.
        var a = function() { return foo; };
        a();
    }

    Examples of correct code for this rule:

    /*eslint no-loop-func: "error"*/
    /*eslint-env es6*/
    
    var a = function() {};
    
    for (var i=10; i; i--) {
        a();
    }
    
    for (var i=10; i; i--) {
        var a = function() {}; // OK, no references to variables in the outer scopes.
        a();
    }
    
    for (let i=10; i; i--) {
        var a = function() { return i; }; // OK, all references are referring to block scoped variables in the loop.
        a();
    }
    
    var foo = 100;
    for (let i=10; i; i--) {
        var a = function() { return foo; }; // OK, all references are referring to never modified variables.
        a();
    }
    //... no modifications of foo after this loop ...

    Source: http://eslint.org/docs/rules/

    There are no issues that match your filters.

    Category
    Status