IHTSDO/snomed-interaction-components

View on GitHub
js/popover.js

Summary

Maintainability
D
2 days
Test Coverage

File popover.js has 555 lines of code (exceeds 250 allowed). Consider refactoring.
Open

!function ($) {
    /* =======================
     *   Popover jQuery Plugin
     *  =======================
     *  Current version: v1.0.0, Last updated: 01-28-2013
Severity: Major
Found in js/popover.js - About 1 day to fix

    Function has too many statements (64). Maximum allowed is 30.
    Open

    !function ($) {
    Severity: Minor
    Found in js/popover.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 too many statements (44). Maximum allowed is 30.
    Open

        Popover.prototype.toggleVisible = function (e, clicked) {
    Severity: Minor
    Found in js/popover.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/

    Method '_init' has a complexity of 17.
    Open

            _init: function(options, popover) {
    Severity: Minor
    Found in js/popover.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/

    Function has a complexity of 15.
    Open

        Popover.prototype.toggleVisible = function (e, clicked) {
    Severity: Minor
    Found in js/popover.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/

    Function toggleVisible has 55 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        Popover.prototype.toggleVisible = function (e, clicked) {
            Popover.lastPopoverClicked = this;
            var clickedDiv = $(clicked);
            if (!clickedDiv) {
                //console.log("ERROR: No element clicked!");
    Severity: Major
    Found in js/popover.js - About 2 hrs to fix

      Function createPopover has 52 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          Popover.prototype.createPopover = function () {
              //Creates popover div that will be populated in the future.
              var popoverWrapperDiv = $(document.createElement("div"));
              popoverWrapperDiv.attr("id", "popoverWrapper");
      
      
      Severity: Major
      Found in js/popover.js - About 2 hrs to fix

        Function _init has 43 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

                _init: function(options, popover) {
                    //Theme modifiers
                    if(typeof(options.backgroundColor) !== 'undefined'){
                        Popover.setBackgroundColor(options.backgroundColor);
                    }
        Severity: Minor
        Found in js/popover.js - About 1 hr to fix

          Function setData has 26 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              OptionsPopover.prototype.setData = function (data) {
                  var contArray = data.contents;
                  var c = "";
                  var i;
          
          
          Severity: Minor
          Found in js/popover.js - About 1 hr to fix

            The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype.
            Open

                    for(property in menu){
            Severity: Minor
            Found in js/popover.js by eslint

            Require Guarding for-in (guard-for-in)

            Looping over objects with a for in loop will include properties that are inherited through the prototype chain. This behavior can lead to unexpected items in your for loop.

            for (key in foo) {
                doSomething(key);
            }

            Note that simply checking foo.hasOwnProperty(key) is likely to cause an error in some cases; see [no-prototype-builtins](no-prototype-builtins.md).

            Rule Details

            This rule is aimed at preventing unexpected behavior that could arise from using a for in loop without filtering the results in the loop. As such, it will warn when for in loops do not filter their results with an if statement.

            Examples of incorrect code for this rule:

            /*eslint guard-for-in: "error"*/
            
            for (key in foo) {
                doSomething(key);
            }

            Examples of correct code for this rule:

            /*eslint guard-for-in: "error"*/
            
            for (key in foo) {
                if (Object.prototype.hasOwnProperty.call(foo, key)) {
                    doSomething(key);
                }
                if ({}.hasOwnProperty.call(foo, key)) {
                    doSomething(key);
                }
            }

            Related Rules

            • [no-prototype-builtins](no-prototype-builtins.md)

            Further Reading

            Expected an assignment or function call and instead saw an expression.
            Open

            !function ($) {
            Severity: Minor
            Found in js/popover.js by eslint

            Disallow Unused Expressions (no-unused-expressions)

            An unused expression which has no effect on the state of the program indicates a logic error.

            For example, n + 1; is not a syntax error, but it might be a typing mistake where a programmer meant an assignment statement n += 1; instead.

            Rule Details

            This rule aims to eliminate unused expressions which have no effect on the state of the program.

            This rule does not apply to function calls or constructor calls with the new operator, because they could have side effects on the state of the program.

            var i = 0;
            function increment() { i += 1; }
            increment(); // return value is unused, but i changed as a side effect
            
            var nThings = 0;
            function Thing() { nThings += 1; }
            new Thing(); // constructed object is unused, but nThings changed as a side effect

            This rule does not apply to directives (which are in the form of literal string expressions such as "use strict"; at the beginning of a script, module, or function).

            Sequence expressions (those using a comma, such as a = 1, b = 2) are always considered unused unless their return value is assigned or used in a condition evaluation, or a function call is made with the sequence expression value.

            Options

            This rule, in its default state, does not require any arguments. If you would like to enable one or more of the following you may pass an object with the options set as follows:

            • allowShortCircuit set to true will allow you to use short circuit evaluations in your expressions (Default: false).
            • allowTernary set to true will enable you to use ternary operators in your expressions similarly to short circuit evaluations (Default: false).
            • allowTaggedTemplates set to true will enable you to use tagged template literals in your expressions (Default: false).

            These options allow unused expressions only if all of the code paths either directly change the state (for example, assignment statement) or could have side effects (for example, function call).

            Examples of incorrect code for the default { "allowShortCircuit": false, "allowTernary": false } options:

            /*eslint no-unused-expressions: "error"*/
            
            0
            
            if(0) 0
            
            {0}
            
            f(0), {}
            
            a && b()
            
            a, b()
            
            c = a, b;
            
            a() && function namedFunctionInExpressionContext () {f();}
            
            (function anIncompleteIIFE () {});
            
            injectGlobal`body{ color: red; }`

            Note that one or more string expression statements (with or without semi-colons) will only be considered as unused if they are not in the beginning of a script, module, or function (alone and uninterrupted by other statements). Otherwise, they will be treated as part of a "directive prologue", a section potentially usable by JavaScript engines. This includes "strict mode" directives.

            "use strict";
            "use asm"
            "use stricter";
            "use babel"
            "any other strings like this in the prologue";

            Examples of correct code for the default { "allowShortCircuit": false, "allowTernary": false } options:

            /*eslint no-unused-expressions: "error"*/
            
            {} // In this context, this is a block statement, not an object literal
            
            {myLabel: someVar} // In this context, this is a block statement with a label and expression, not an object literal
            
            function namedFunctionDeclaration () {}
            
            (function aGenuineIIFE () {}());
            
            f()
            
            a = 0
            
            new C
            
            delete a.b
            
            void a

            allowShortCircuit

            Examples of incorrect code for the { "allowShortCircuit": true } option:

            /*eslint no-unused-expressions: ["error", { "allowShortCircuit": true }]*/
            
            a || b

            Examples of correct code for the { "allowShortCircuit": true } option:

            /*eslint no-unused-expressions: ["error", { "allowShortCircuit": true }]*/
            
            a && b()
            a() || (b = c)

            allowTernary

            Examples of incorrect code for the { "allowTernary": true } option:

            /*eslint no-unused-expressions: ["error", { "allowTernary": true }]*/
            
            a ? b : 0
            a ? b : c()

            Examples of correct code for the { "allowTernary": true } option:

            /*eslint no-unused-expressions: ["error", { "allowTernary": true }]*/
            
            a ? b() : c()
            a ? (b = c) : d()

            allowShortCircuit and allowTernary

            Examples of correct code for the { "allowShortCircuit": true, "allowTernary": true } options:

            /*eslint no-unused-expressions: ["error", { "allowShortCircuit": true, "allowTernary": true }]*/
            
            a ? b() || (c = d) : e()

            allowTaggedTemplates

            Examples of incorrect code for the { "allowTaggedTemplates": true } option:

            /*eslint no-unused-expressions: ["error", { "allowTaggedTemplates": true }]*/
            
            `some untagged template string`;

            Examples of correct code for the { "allowTaggedTemplates": true } option:

            /*eslint no-unused-expressions: ["error", { "allowTaggedTemplates": true }]*/
            
            tag`some tagged template string`;

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

            The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype.
            Open

                    for(property in newMenu){
            Severity: Minor
            Found in js/popover.js by eslint

            Require Guarding for-in (guard-for-in)

            Looping over objects with a for in loop will include properties that are inherited through the prototype chain. This behavior can lead to unexpected items in your for loop.

            for (key in foo) {
                doSomething(key);
            }

            Note that simply checking foo.hasOwnProperty(key) is likely to cause an error in some cases; see [no-prototype-builtins](no-prototype-builtins.md).

            Rule Details

            This rule is aimed at preventing unexpected behavior that could arise from using a for in loop without filtering the results in the loop. As such, it will warn when for in loops do not filter their results with an if statement.

            Examples of incorrect code for this rule:

            /*eslint guard-for-in: "error"*/
            
            for (key in foo) {
                doSomething(key);
            }

            Examples of correct code for this rule:

            /*eslint guard-for-in: "error"*/
            
            for (key in foo) {
                if (Object.prototype.hasOwnProperty.call(foo, key)) {
                    doSomething(key);
                }
                if ({}.hasOwnProperty.call(foo, key)) {
                    doSomething(key);
                }
            }

            Related Rules

            • [no-prototype-builtins](no-prototype-builtins.md)

            Further Reading

            TODO found
            Open

                    //TODO: Fix repetition.
            Severity: Minor
            Found in js/popover.js by fixme

            TODO found
            Open

                 *                       //TODO: Document more.
            Severity: Minor
            Found in js/popover.js by fixme

            TODO found
            Open

                        //TODO: Trigger color change event and move to OptionsPopover.
            Severity: Minor
            Found in js/popover.js by fixme

            TODO found
            Open

                        //TODO: Rename disableBackButton option.
            Severity: Minor
            Found in js/popover.js by fixme

            TODO found
            Open

                            //TODO: Return if not visible.
            Severity: Minor
            Found in js/popover.js by fixme

            TODO found
            Open

                    //TODO: In the future, add passed id to selected div's data-* or add specific class.
            Severity: Minor
            Found in js/popover.js by fixme

            TODO found
            Open

                    //TODO: Make more readable.
            Severity: Minor
            Found in js/popover.js by fixme

            Wrap an immediate function invocation in parentheses.
            Open

            !function ($) {
            Severity: Minor
            Found in js/popover.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/

            There are no issues that match your filters.

            Category
            Status