onlyurei/knockout-spa

View on GitHub
app/shared/api/api.js

Summary

Maintainability
B
5 hrs
Test Coverage

Function call has 77 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    call: function (apiPackage, apiMethod, urlParams, data, error, loading, synchronousOrSocket) {
      var api = Api.list[apiPackage][apiMethod];

      if (!api) {
        return $.Deferred().reject('Api not found.');
Severity: Major
Found in app/shared/api/api.js - About 3 hrs to fix

    Method 'call' has a complexity of 14.
    Open

        call: function (apiPackage, apiMethod, urlParams, data, error, loading, synchronousOrSocket) {
    Severity: Minor
    Found in app/shared/api/api.js by eslint

    Limit Cyclomatic Complexity (complexity)

    Cyclomatic complexity measures the number of linearly independent paths through a program's source code. This rule allows setting a cyclomatic complexity threshold.

    function a(x) {
        if (true) {
            return x; // 1st path
        } else if (false) {
            return x+1; // 2nd path
        } else {
            return 4; // 3rd path
        }
    }

    Rule Details

    This rule is aimed at reducing code complexity by capping the amount of cyclomatic complexity allowed in a program. As such, it will warn when the cyclomatic complexity crosses the configured threshold (default is 20).

    Examples of incorrect code for a maximum of 2:

    /*eslint complexity: ["error", 2]*/
    
    function a(x) {
        if (true) {
            return x;
        } else if (false) {
            return x+1;
        } else {
            return 4; // 3rd path
        }
    }

    Examples of correct code for a maximum of 2:

    /*eslint complexity: ["error", 2]*/
    
    function a(x) {
        if (true) {
            return x;
        } else {
            return 4;
        }
    }

    Options

    Optionally, you may specify a max object property:

    "complexity": ["error", 2]

    is equivalent to

    "complexity": ["error", { "max": 2 }]

    Deprecated: the object property maximum is deprecated. Please use the property max instead.

    When Not To Use It

    If you can't determine an appropriate complexity limit for your code, then it's best to disable this rule.

    Further Reading

    Related Rules

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

    Method 'call' has too many statements (35). Maximum allowed is 30.
    Open

        call: function (apiPackage, apiMethod, urlParams, data, error, loading, synchronousOrSocket) {
    Severity: Minor
    Found in app/shared/api/api.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 has a complexity of 7.
    Open

              io.socket[type.toLowerCase()](url, data, function (resData, jwres) {
    Severity: Minor
    Found in app/shared/api/api.js by eslint

    Limit Cyclomatic Complexity (complexity)

    Cyclomatic complexity measures the number of linearly independent paths through a program's source code. This rule allows setting a cyclomatic complexity threshold.

    function a(x) {
        if (true) {
            return x; // 1st path
        } else if (false) {
            return x+1; // 2nd path
        } else {
            return 4; // 3rd path
        }
    }

    Rule Details

    This rule is aimed at reducing code complexity by capping the amount of cyclomatic complexity allowed in a program. As such, it will warn when the cyclomatic complexity crosses the configured threshold (default is 20).

    Examples of incorrect code for a maximum of 2:

    /*eslint complexity: ["error", 2]*/
    
    function a(x) {
        if (true) {
            return x;
        } else if (false) {
            return x+1;
        } else {
            return 4; // 3rd path
        }
    }

    Examples of correct code for a maximum of 2:

    /*eslint complexity: ["error", 2]*/
    
    function a(x) {
        if (true) {
            return x;
        } else {
            return 4;
        }
    }

    Options

    Optionally, you may specify a max object property:

    "complexity": ["error", 2]

    is equivalent to

    "complexity": ["error", { "max": 2 }]

    Deprecated: the object property maximum is deprecated. Please use the property max instead.

    When Not To Use It

    If you can't determine an appropriate complexity limit for your code, then it's best to disable this rule.

    Further Reading

    Related Rules

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

    Consider simplifying this complex logical expression.
    Open

          if (Object.isObject(synchronousOrSocket)) {
    
            var deferred = $.Deferred();
    
            require(['io'], function (io) {
    Severity: Major
    Found in app/shared/api/api.js - About 1 hr to fix

      Function call has 7 arguments (exceeds 4 allowed). Consider refactoring.
      Open

          call: function (apiPackage, apiMethod, urlParams, data, error, loading, synchronousOrSocket) {
      Severity: Major
      Found in app/shared/api/api.js - About 50 mins to fix

        Avoid too many return statements within this function.
        Open

                  return ajax;
        Severity: Major
        Found in app/shared/api/api.js - About 30 mins to fix

          Expected '!==' and instead saw '!='.
          Open

                  if ((type != 'GET') && data) {
          Severity: Minor
          Found in app/shared/api/api.js by eslint

          Require === and !== (eqeqeq)

          It is considered good practice to use the type-safe equality operators === and !== instead of their regular counterparts == and !=.

          The reason for this is that == and != do type coercion which follows the rather obscure Abstract Equality Comparison Algorithm. For instance, the following statements are all considered true:

          • [] == false
          • [] == ![]
          • 3 == "03"

          If one of those occurs in an innocent-looking statement such as a == b the actual problem is very difficult to spot.

          Rule Details

          This rule is aimed at eliminating the type-unsafe equality operators.

          Examples of incorrect code for this rule:

          /*eslint eqeqeq: "error"*/
          
          if (x == 42) { }
          
          if ("" == text) { }
          
          if (obj.getStuff() != undefined) { }

          The --fix option on the command line automatically fixes some problems reported by this rule. A problem is only fixed if one of the operands is a typeof expression, or if both operands are literals with the same type.

          Options

          always

          The "always" option (default) enforces the use of === and !== in every situation (except when you opt-in to more specific handling of null [see below]).

          Examples of incorrect code for the "always" option:

          /*eslint eqeqeq: ["error", "always"]*/
          
          a == b
          foo == true
          bananas != 1
          value == undefined
          typeof foo == 'undefined'
          'hello' != 'world'
          0 == 0
          true == true
          foo == null

          Examples of correct code for the "always" option:

          /*eslint eqeqeq: ["error", "always"]*/
          
          a === b
          foo === true
          bananas !== 1
          value === undefined
          typeof foo === 'undefined'
          'hello' !== 'world'
          0 === 0
          true === true
          foo === null

          This rule optionally takes a second argument, which should be an object with the following supported properties:

          • "null": Customize how this rule treats null literals. Possible values:
            • always (default) - Always use === or !==.
            • never - Never use === or !== with null.
            • ignore - Do not apply this rule to null.

          smart

          The "smart" option enforces the use of === and !== except for these cases:

          • Comparing two literal values
          • Evaluating the value of typeof
          • Comparing against null

          Examples of incorrect code for the "smart" option:

          /*eslint eqeqeq: ["error", "smart"]*/
          
          // comparing two variables requires ===
          a == b
          
          // only one side is a literal
          foo == true
          bananas != 1
          
          // comparing to undefined requires ===
          value == undefined

          Examples of correct code for the "smart" option:

          /*eslint eqeqeq: ["error", "smart"]*/
          
          typeof foo == 'undefined'
          'hello' != 'world'
          0 == 0
          true == true
          foo == null

          allow-null

          Deprecated: Instead of using this option use "always" and pass a "null" option property with value "ignore". This will tell eslint to always enforce strict equality except when comparing with the null literal.

          ["error", "always", {"null": "ignore"}]

          When Not To Use It

          If you don't want to enforce a style for using equality operators, then it's safe to disable this rule. Source: http://eslint.org/docs/rules/

          Unexpected require().
          Open

                  require(['io'], function (io) {
          Severity: Minor
          Found in app/shared/api/api.js by eslint

          Enforce require() on the top-level module scope (global-require)

          In Node.js, module dependencies are included using the require() function, such as:

          var fs = require("fs");

          While require() may be called anywhere in code, some style guides prescribe that it should be called only in the top level of a module to make it easier to identify dependencies. For instance, it's arguably harder to identify dependencies when they are deeply nested inside of functions and other statements:

          function foo() {
          
              if (condition) {
                  var fs = require("fs");
              }
          }

          Since require() does a synchronous load, it can cause performance problems when used in other locations.

          Further, ES6 modules mandate that import and export statements can only occur in the top level of the module's body.

          Rule Details

          This rule requires all calls to require() to be at the top level of the module, similar to ES6 import and export statements, which also can occur only at the top level.

          Examples of incorrect code for this rule:

          /*eslint global-require: "error"*/
          /*eslint-env es6*/
          
          // calling require() inside of a function is not allowed
          function readFile(filename, callback) {
              var fs = require('fs');
              fs.readFile(filename, callback)
          }
          
          // conditional requires like this are also not allowed
          if (DEBUG) { require('debug'); }
          
          // a require() in a switch statement is also flagged
          switch(x) { case '1': require('1'); break; }
          
          // you may not require() inside an arrow function body
          var getModule = (name) => require(name);
          
          // you may not require() inside of a function body as well
          function getModule(name) { return require(name); }
          
          // you may not require() inside of a try/catch block
          try {
              require(unsafeModule);
          } catch(e) {
              console.log(e);
          }

          Examples of correct code for this rule:

          /*eslint global-require: "error"*/
          
          // all these variations of require() are ok
          require('x');
          var y = require('y');
          var z;
          z = require('z').initialize();
          
          // requiring a module and using it in a function is ok
          var fs = require('fs');
          function readFile(filename, callback) {
              fs.readFile(filename, callback)
          }
          
          // you can use a ternary to determine which module to require
          var logger = DEBUG ? require('dev-logger') : require('logger');
          
          // if you want you can require() at the end of your module
          function doSomethingA() {}
          function doSomethingB() {}
          var x = require("x"),
              z = require("z");

          When Not To Use It

          If you have a module that must be initialized with information that comes from the file-system or if a module is only used in very rare situations and will cause significant overhead to load it may make sense to disable the rule. If you need to require() an optional dependency inside of a try/catch, you can disable this rule for just that dependency using the // eslint-disable-line global-require comment. Source: http://eslint.org/docs/rules/

          There are no issues that match your filters.

          Category
          Status