mariuszfoltak/angular2-datatable

View on GitHub

Showing 8 of 8 total issues

File DataTable.spec.ts has 390 lines of code (exceeds 250 allowed). Consider refactoring.
Open

///<reference path="../node_modules/@types/jasmine/index.d.ts"/>
import {SimpleChange, Component} from "@angular/core";
import {DataTable, PageEvent, SortEvent} from "./DataTable";
import {TestBed, ComponentFixture} from "@angular/core/testing";
import {By} from "@angular/platform-browser";
Severity: Minor
Found in src/DataTable.spec.ts - About 5 hrs to fix

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

    module.exports = function (config) {
    
        var appBase = 'lib/';       // transpiled app JS and map files
        var appSrcBase = 'src/';       // app source TS files
        var appAssets = '/base/lib/'; // component assets fetched by Angular's compiler
    Severity: Major
    Found in karma.conf.js - About 4 hrs to fix

      Function ngOnChanges has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
      Open

          public ngOnChanges(changes: {[key: string]: SimpleChange}): any {
              if (changes["rowsOnPage"]) {
                  this.rowsOnPage = changes["rowsOnPage"].previousValue;
                  this.setPage(this.activePage, changes["rowsOnPage"].currentValue);
                  this.mustRecalculateData = true;
      Severity: Minor
      Found in src/DataTable.ts - About 35 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

      Function setPage has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
      Open

          public setPage(activePage: number, rowsOnPage: number): void {
              if (this.rowsOnPage !== rowsOnPage || this.activePage !== activePage) {
                  this.activePage = this.activePage !== activePage ? activePage : this.calculateNewActivePage(this.rowsOnPage, rowsOnPage);
                  this.rowsOnPage = rowsOnPage;
                  this.mustRecalculateData = true;
      Severity: Minor
      Found in src/DataTable.ts - About 25 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

      Move the invocation into the parens that contain the function.
      Open

      (function (global) {
      Severity: Minor
      Found in examples/systemjs/systemjs.config.js by eslint

      Require IIFEs to be Wrapped (wrap-iife)

      You can immediately invoke function expressions, but not function declarations. A common technique to create an immediately-invoked function expression (IIFE) is to wrap a function declaration in parentheses. The opening parentheses causes the contained function to be parsed as an expression, rather than a declaration.

      // function expression could be unwrapped
      var x = function () { return { y: 1 };}();
      
      // function declaration must be wrapped
      function () { /* side effects */ }(); // SyntaxError

      Rule Details

      This rule requires all immediately-invoked function expressions to be wrapped in parentheses.

      Options

      This rule has two options, a string option and an object option.

      String option:

      • "outside" enforces always wrapping the call expression. The default is "outside".
      • "inside" enforces always wrapping the function expression.
      • "any" enforces always wrapping, but allows either style.

      Object option:

      • "functionPrototypeMethods": true additionally enforces wrapping function expressions invoked using .call and .apply. The default is false.

      outside

      Examples of incorrect code for the default "outside" option:

      /*eslint wrap-iife: ["error", "outside"]*/
      
      var x = function () { return { y: 1 };}(); // unwrapped
      var x = (function () { return { y: 1 };})(); // wrapped function expression

      Examples of correct code for the default "outside" option:

      /*eslint wrap-iife: ["error", "outside"]*/
      
      var x = (function () { return { y: 1 };}()); // wrapped call expression

      inside

      Examples of incorrect code for the "inside" option:

      /*eslint wrap-iife: ["error", "inside"]*/
      
      var x = function () { return { y: 1 };}(); // unwrapped
      var x = (function () { return { y: 1 };}()); // wrapped call expression

      Examples of correct code for the "inside" option:

      /*eslint wrap-iife: ["error", "inside"]*/
      
      var x = (function () { return { y: 1 };})(); // wrapped function expression

      any

      Examples of incorrect code for the "any" option:

      /*eslint wrap-iife: ["error", "any"]*/
      
      var x = function () { return { y: 1 };}(); // unwrapped

      Examples of correct code for the "any" option:

      /*eslint wrap-iife: ["error", "any"]*/
      
      var x = (function () { return { y: 1 };}()); // wrapped call expression
      var x = (function () { return { y: 1 };})(); // wrapped function expression

      functionPrototypeMethods

      Examples of incorrect code for this rule with the "inside", { "functionPrototypeMethods": true } options:

      /* eslint wrap-iife: [2, "inside", { functionPrototypeMethods: true }] */
      
      var x = function(){ foo(); }()
      var x = (function(){ foo(); }())
      var x = function(){ foo(); }.call(bar)
      var x = (function(){ foo(); }.call(bar))

      Examples of correct code for this rule with the "inside", { "functionPrototypeMethods": true } options:

      /* eslint wrap-iife: [2, "inside", { functionPrototypeMethods: true }] */
      
      var x = (function(){ foo(); })()
      var x = (function(){ foo(); }).call(bar)

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

      Move the invocation into the parens that contain the function.
      Open

      (function (global) {
      Severity: Minor
      Found in systemjs.config.js by eslint

      Require IIFEs to be Wrapped (wrap-iife)

      You can immediately invoke function expressions, but not function declarations. A common technique to create an immediately-invoked function expression (IIFE) is to wrap a function declaration in parentheses. The opening parentheses causes the contained function to be parsed as an expression, rather than a declaration.

      // function expression could be unwrapped
      var x = function () { return { y: 1 };}();
      
      // function declaration must be wrapped
      function () { /* side effects */ }(); // SyntaxError

      Rule Details

      This rule requires all immediately-invoked function expressions to be wrapped in parentheses.

      Options

      This rule has two options, a string option and an object option.

      String option:

      • "outside" enforces always wrapping the call expression. The default is "outside".
      • "inside" enforces always wrapping the function expression.
      • "any" enforces always wrapping, but allows either style.

      Object option:

      • "functionPrototypeMethods": true additionally enforces wrapping function expressions invoked using .call and .apply. The default is false.

      outside

      Examples of incorrect code for the default "outside" option:

      /*eslint wrap-iife: ["error", "outside"]*/
      
      var x = function () { return { y: 1 };}(); // unwrapped
      var x = (function () { return { y: 1 };})(); // wrapped function expression

      Examples of correct code for the default "outside" option:

      /*eslint wrap-iife: ["error", "outside"]*/
      
      var x = (function () { return { y: 1 };}()); // wrapped call expression

      inside

      Examples of incorrect code for the "inside" option:

      /*eslint wrap-iife: ["error", "inside"]*/
      
      var x = function () { return { y: 1 };}(); // unwrapped
      var x = (function () { return { y: 1 };}()); // wrapped call expression

      Examples of correct code for the "inside" option:

      /*eslint wrap-iife: ["error", "inside"]*/
      
      var x = (function () { return { y: 1 };})(); // wrapped function expression

      any

      Examples of incorrect code for the "any" option:

      /*eslint wrap-iife: ["error", "any"]*/
      
      var x = function () { return { y: 1 };}(); // unwrapped

      Examples of correct code for the "any" option:

      /*eslint wrap-iife: ["error", "any"]*/
      
      var x = (function () { return { y: 1 };}()); // wrapped call expression
      var x = (function () { return { y: 1 };})(); // wrapped function expression

      functionPrototypeMethods

      Examples of incorrect code for this rule with the "inside", { "functionPrototypeMethods": true } options:

      /* eslint wrap-iife: [2, "inside", { functionPrototypeMethods: true }] */
      
      var x = function(){ foo(); }()
      var x = (function(){ foo(); }())
      var x = function(){ foo(); }.call(bar)
      var x = (function(){ foo(); }.call(bar))

      Examples of correct code for this rule with the "inside", { "functionPrototypeMethods": true } options:

      /* eslint wrap-iife: [2, "inside", { functionPrototypeMethods: true }] */
      
      var x = (function(){ foo(); })()
      var x = (function(){ foo(); }).call(bar)

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

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

          return path.slice(-3) == '.js';
      Severity: Minor
      Found in karma-test-shim.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/

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

          return isJsFile(path) && (path.substr(0, builtPath.length) == builtPath);
      Severity: Minor
      Found in karma-test-shim.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/

      Severity
      Category
      Status
      Source
      Language