radare/radare2-webui

View on GitHub
www/p/lib/js/main.js

Summary

Maintainability
F
5 days
Test Coverage

eval can be harmful.
Open

                    x = eval(cmd);
Severity: Minor
Found in www/p/lib/js/main.js by eslint

Disallow eval() (no-eval)

JavaScript's eval() function is potentially dangerous and is often misused. Using eval() on untrusted code can open a program up to several different injection attacks. The use of eval() in most contexts can be substituted for a better, alternative approach to a problem.

var obj = { x: "foo" },
    key = "x",
    value = eval("obj." + key);

Rule Details

This rule is aimed at preventing potentially dangerous, unnecessary, and slow code by disallowing the use of the eval() function. As such, it will warn whenever the eval() function is used.

Examples of incorrect code for this rule:

/*eslint no-eval: "error"*/

var obj = { x: "foo" },
    key = "x",
    value = eval("obj." + key);

(0, eval)("var a = 0");

var foo = eval;
foo("var a = 0");

// This `this` is the global object.
this.eval("var a = 0");

Example of additional incorrect code for this rule when browser environment is set to true:

/*eslint no-eval: "error"*/
/*eslint-env browser*/

window.eval("var a = 0");

Example of additional incorrect code for this rule when node environment is set to true:

/*eslint no-eval: "error"*/
/*eslint-env node*/

global.eval("var a = 0");

Examples of correct code for this rule:

/*eslint no-eval: "error"*/
/*eslint-env es6*/

var obj = { x: "foo" },
    key = "x",
    value = obj[key];

class A {
    foo() {
        // This is a user-defined method.
        this.eval("var a = 0");
    }

    eval() {
    }
}

Options

This rule has an option to allow indirect calls to eval. Indirect calls to eval are less dangerous than direct calls to eval because they cannot dynamically change the scope. Because of this, they also will not negatively impact performance to the degree of direct eval.

{
    "no-eval": ["error", {"allowIndirect": true}] // default is false
}

Example of incorrect code for this rule with the {"allowIndirect": true} option:

/*eslint no-eval: "error"*/

var obj = { x: "foo" },
    key = "x",
    value = eval("obj." + key);

Examples of correct code for this rule with the {"allowIndirect": true} option:

/*eslint no-eval: "error"*/

(0, eval)("var a = 0");

var foo = eval;
foo("var a = 0");

this.eval("var a = 0");
/*eslint no-eval: "error"*/
/*eslint-env browser*/

window.eval("var a = 0");
/*eslint no-eval: "error"*/
/*eslint-env node*/

global.eval("var a = 0");

Known Limitations

  • This rule is warning every eval() even if the eval is not global's. This behavior is in order to detect calls of direct eval. Such as:
module.exports = function(eval) {
      // If the value of this `eval` is built-in `eval` function, this is a
      // call of direct `eval`.
      eval("var a = 0");
  };
  • This rule cannot catch renaming the global object. Such as:
var foo = window;
  foo.eval("var a = 0");

Further Reading

Related Rules

File main.js has 322 lines of code (exceeds 250 allowed). Consider refactoring.
Open

var myLayout;

$(document).ready(function() {

    r2.cmd('e scr.html=false');
Severity: Minor
Found in www/p/lib/js/main.js - About 3 hrs to fix

    Function render_functions has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
    Open

    function render_functions(functions) {
        var imports = null;
        r2.cmdj('iij', function(x) {
            imports = x;
        });
    Severity: Minor
    Found in www/p/lib/js/main.js - About 3 hrs 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 has too many statements (42). Maximum allowed is 30.
    Open

    $(document).ready(function() {
    Severity: Minor
    Found in www/p/lib/js/main.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 10.
    Open

        $('#command').keypress(function(inEvent) {
    Severity: Minor
    Found in www/p/lib/js/main.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 10.
    Open

        $('#command').keydown(function(inEvent) {
    Severity: Minor
    Found in www/p/lib/js/main.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 'render_functions' has a complexity of 9.
    Open

    function render_functions(functions) {
    Severity: Minor
    Found in www/p/lib/js/main.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 'select' has a complexity of 8.
    Open

            select: function(event, ui) {
    Severity: Minor
    Found in www/p/lib/js/main.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 render_functions has 30 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    function render_functions(functions) {
        var imports = null;
        r2.cmdj('iij', function(x) {
            imports = x;
        });
    Severity: Minor
    Found in www/p/lib/js/main.js - About 1 hr to fix

      Function render_history has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
      Open

      function render_history() {
          var html = '<div>';
          for (var i in r2ui.history) {
              if (i > r2ui.history_idx - 8 && i < r2ui.history_idx + 3) {
                  var flag = r2.get_flag_names(r2ui.history[i]);
      Severity: Minor
      Found in www/p/lib/js/main.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

      Unexpected string concatenation of literals.
      Open

                      label: '<span class=\'flag import addr addr_' + '0x' + f.plt.toString(16) + '\'>' + f.name + '</span>',
      Severity: Minor
      Found in www/p/lib/js/main.js by eslint

      Disallow unnecessary concatenation of strings (no-useless-concat)

      It's unnecessary to concatenate two strings together, such as:

      var foo = "a" + "b";

      This code is likely the result of refactoring where a variable was removed from the concatenation (such as "a" + b + "b"). In such a case, the concatenation isn't important and the code can be rewritten as:

      var foo = "ab";

      Rule Details

      This rule aims to flag the concatenation of 2 literals when they could be combined into a single literal. Literals can be strings or template literals.

      Examples of incorrect code for this rule:

      /*eslint no-useless-concat: "error"*/
      /*eslint-env es6*/
      
      // these are the same as "10"
      var a = `some` + `string`;
      var a = '1' + '0';
      var a = '1' + `0`;
      var a = `1` + '0';
      var a = `1` + `0`;

      Examples of correct code for this rule:

      /*eslint no-useless-concat: "error"*/
      
      // when a non string is included
      var c = a + b;
      var c = '1' + a;
      var a = 1 + '1';
      var c = 1 - 2;
      // when the string concatenation is multiline
      var c = "foo" +
          "bar";

      When Not To Use It

      If you don't want to be notified about unnecessary string concatenation, you can safely disable this rule. Source: http://eslint.org/docs/rules/

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

                  if (cmd != '') {
      Severity: Minor
      Found in www/p/lib/js/main.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

                      } else if (r2ui.console_lang == 'js') {
      Severity: Minor
      Found in www/p/lib/js/main.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

                  if (reloadUI && r2ui.console_lang == 'r2') {
      Severity: Minor
      Found in www/p/lib/js/main.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 string concatenation of literals.
      Open

                  label: '<span class=\'flag symbol addr addr_' + '0x' + s.addr.toString(16) + '\'>' + s.name + '</span>',
      Severity: Minor
      Found in www/p/lib/js/main.js by eslint

      Disallow unnecessary concatenation of strings (no-useless-concat)

      It's unnecessary to concatenate two strings together, such as:

      var foo = "a" + "b";

      This code is likely the result of refactoring where a variable was removed from the concatenation (such as "a" + b + "b"). In such a case, the concatenation isn't important and the code can be rewritten as:

      var foo = "ab";

      Rule Details

      This rule aims to flag the concatenation of 2 literals when they could be combined into a single literal. Literals can be strings or template literals.

      Examples of incorrect code for this rule:

      /*eslint no-useless-concat: "error"*/
      /*eslint-env es6*/
      
      // these are the same as "10"
      var a = `some` + `string`;
      var a = '1' + '0';
      var a = '1' + `0`;
      var a = `1` + '0';
      var a = `1` + `0`;

      Examples of correct code for this rule:

      /*eslint no-useless-concat: "error"*/
      
      // when a non string is included
      var c = a + b;
      var c = '1' + a;
      var a = 1 + '1';
      var c = 1 - 2;
      // when the string concatenation is multiline
      var c = "foo" +
          "bar";

      When Not To Use It

      If you don't want to be notified about unnecessary string concatenation, you can safely disable this rule. Source: http://eslint.org/docs/rules/

      Unexpected string concatenation of literals.
      Open

                  children: [{label: 'offset: ' + '0x' + s.addr.toString(16)}, {label: 'size: ' + s.size}] };
      Severity: Minor
      Found in www/p/lib/js/main.js by eslint

      Disallow unnecessary concatenation of strings (no-useless-concat)

      It's unnecessary to concatenate two strings together, such as:

      var foo = "a" + "b";

      This code is likely the result of refactoring where a variable was removed from the concatenation (such as "a" + b + "b"). In such a case, the concatenation isn't important and the code can be rewritten as:

      var foo = "ab";

      Rule Details

      This rule aims to flag the concatenation of 2 literals when they could be combined into a single literal. Literals can be strings or template literals.

      Examples of incorrect code for this rule:

      /*eslint no-useless-concat: "error"*/
      /*eslint-env es6*/
      
      // these are the same as "10"
      var a = `some` + `string`;
      var a = '1' + '0';
      var a = '1' + `0`;
      var a = `1` + '0';
      var a = `1` + `0`;

      Examples of correct code for this rule:

      /*eslint no-useless-concat: "error"*/
      
      // when a non string is included
      var c = a + b;
      var c = '1' + a;
      var a = 1 + '1';
      var c = 1 - 2;
      // when the string concatenation is multiline
      var c = "foo" +
          "bar";

      When Not To Use It

      If you don't want to be notified about unnecessary string concatenation, you can safely disable this rule. 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 (var i in flags) {
      Severity: Minor
      Found in www/p/lib/js/main.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

      Unexpected string concatenation of literals.
      Open

                  children: [{label: 'offset: ' + '0x' + r.vaddr.toString(16)}, {label: 'type: ' + r.type}] };
      Severity: Minor
      Found in www/p/lib/js/main.js by eslint

      Disallow unnecessary concatenation of strings (no-useless-concat)

      It's unnecessary to concatenate two strings together, such as:

      var foo = "a" + "b";

      This code is likely the result of refactoring where a variable was removed from the concatenation (such as "a" + b + "b"). In such a case, the concatenation isn't important and the code can be rewritten as:

      var foo = "ab";

      Rule Details

      This rule aims to flag the concatenation of 2 literals when they could be combined into a single literal. Literals can be strings or template literals.

      Examples of incorrect code for this rule:

      /*eslint no-useless-concat: "error"*/
      /*eslint-env es6*/
      
      // these are the same as "10"
      var a = `some` + `string`;
      var a = '1' + '0';
      var a = '1' + `0`;
      var a = `1` + '0';
      var a = `1` + `0`;

      Examples of correct code for this rule:

      /*eslint no-useless-concat: "error"*/
      
      // when a non string is included
      var c = a + b;
      var c = '1' + a;
      var a = 1 + '1';
      var c = 1 - 2;
      // when the string concatenation is multiline
      var c = "foo" +
          "bar";

      When Not To Use It

      If you don't want to be notified about unnecessary string concatenation, you can safely disable this rule. Source: http://eslint.org/docs/rules/

      Unexpected string concatenation of literals.
      Open

                      children: [{label: 'offset: ' + '0x' + f.offset.toString(16)},  {label: 'size: ' + f.size}]
      Severity: Minor
      Found in www/p/lib/js/main.js by eslint

      Disallow unnecessary concatenation of strings (no-useless-concat)

      It's unnecessary to concatenate two strings together, such as:

      var foo = "a" + "b";

      This code is likely the result of refactoring where a variable was removed from the concatenation (such as "a" + b + "b"). In such a case, the concatenation isn't important and the code can be rewritten as:

      var foo = "ab";

      Rule Details

      This rule aims to flag the concatenation of 2 literals when they could be combined into a single literal. Literals can be strings or template literals.

      Examples of incorrect code for this rule:

      /*eslint no-useless-concat: "error"*/
      /*eslint-env es6*/
      
      // these are the same as "10"
      var a = `some` + `string`;
      var a = '1' + '0';
      var a = '1' + `0`;
      var a = `1` + '0';
      var a = `1` + `0`;

      Examples of correct code for this rule:

      /*eslint no-useless-concat: "error"*/
      
      // when a non string is included
      var c = a + b;
      var c = '1' + a;
      var a = 1 + '1';
      var c = 1 - 2;
      // when the string concatenation is multiline
      var c = "foo" +
          "bar";

      When Not To Use It

      If you don't want to be notified about unnecessary string concatenation, you can safely disable this rule. 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 (var i in symbols) {
      Severity: Minor
      Found in www/p/lib/js/main.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

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

          for (var i in relocs) {
      Severity: Minor
      Found in www/p/lib/js/main.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

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

                      for (var j in f.callrefs) {
      Severity: Minor
      Found in www/p/lib/js/main.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

      Unexpected string concatenation of literals.
      Open

                      {label: 'vaddr: ' + '0x' + f.vaddr.toString(16)},
      Severity: Minor
      Found in www/p/lib/js/main.js by eslint

      Disallow unnecessary concatenation of strings (no-useless-concat)

      It's unnecessary to concatenate two strings together, such as:

      var foo = "a" + "b";

      This code is likely the result of refactoring where a variable was removed from the concatenation (such as "a" + b + "b"). In such a case, the concatenation isn't important and the code can be rewritten as:

      var foo = "ab";

      Rule Details

      This rule aims to flag the concatenation of 2 literals when they could be combined into a single literal. Literals can be strings or template literals.

      Examples of incorrect code for this rule:

      /*eslint no-useless-concat: "error"*/
      /*eslint-env es6*/
      
      // these are the same as "10"
      var a = `some` + `string`;
      var a = '1' + '0';
      var a = '1' + `0`;
      var a = `1` + '0';
      var a = `1` + `0`;

      Examples of correct code for this rule:

      /*eslint no-useless-concat: "error"*/
      
      // when a non string is included
      var c = a + b;
      var c = '1' + a;
      var a = 1 + '1';
      var c = 1 - 2;
      // when the string concatenation is multiline
      var c = "foo" +
          "bar";

      When Not To Use It

      If you don't want to be notified about unnecessary string concatenation, you can safely disable this rule. Source: http://eslint.org/docs/rules/

      Unexpected string concatenation of literals.
      Open

                      {label: 'paddr: ' + '0x' + f.paddr.toString(16)},
      Severity: Minor
      Found in www/p/lib/js/main.js by eslint

      Disallow unnecessary concatenation of strings (no-useless-concat)

      It's unnecessary to concatenate two strings together, such as:

      var foo = "a" + "b";

      This code is likely the result of refactoring where a variable was removed from the concatenation (such as "a" + b + "b"). In such a case, the concatenation isn't important and the code can be rewritten as:

      var foo = "ab";

      Rule Details

      This rule aims to flag the concatenation of 2 literals when they could be combined into a single literal. Literals can be strings or template literals.

      Examples of incorrect code for this rule:

      /*eslint no-useless-concat: "error"*/
      /*eslint-env es6*/
      
      // these are the same as "10"
      var a = `some` + `string`;
      var a = '1' + '0';
      var a = '1' + `0`;
      var a = `1` + '0';
      var a = `1` + `0`;

      Examples of correct code for this rule:

      /*eslint no-useless-concat: "error"*/
      
      // when a non string is included
      var c = a + b;
      var c = '1' + a;
      var a = 1 + '1';
      var c = 1 - 2;
      // when the string concatenation is multiline
      var c = "foo" +
          "bar";

      When Not To Use It

      If you don't want to be notified about unnecessary string concatenation, you can safely disable this rule. Source: http://eslint.org/docs/rules/

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

                  var reloadUI = cmd == '';
      Severity: Minor
      Found in www/p/lib/js/main.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

                      if (r2ui.console_lang == 'r2') {
      Severity: Minor
      Found in www/p/lib/js/main.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/

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

          for (var i in imports) {
      Severity: Minor
      Found in www/p/lib/js/main.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 '===' and instead saw '=='.
      Open

                  if (i == r2ui.history_idx - 1) html += ' &gt; <span class=\'history history_idx addr addr_' + r2ui.history[i] + ' history_idx_' + i + '\'>' + flag + '</span>';
      Severity: Minor
      Found in www/p/lib/js/main.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

                  if (e.keyCode == '38' || e.keyCode == '40') {
      Severity: Minor
      Found in www/p/lib/js/main.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 string concatenation of literals.
      Open

                      label: '<span class=\'flag function addr addr_' + '0x' + f.offset.toString(16) + '\'>' + f.name + '</span>',
      Severity: Minor
      Found in www/p/lib/js/main.js by eslint

      Disallow unnecessary concatenation of strings (no-useless-concat)

      It's unnecessary to concatenate two strings together, such as:

      var foo = "a" + "b";

      This code is likely the result of refactoring where a variable was removed from the concatenation (such as "a" + b + "b"). In such a case, the concatenation isn't important and the code can be rewritten as:

      var foo = "ab";

      Rule Details

      This rule aims to flag the concatenation of 2 literals when they could be combined into a single literal. Literals can be strings or template literals.

      Examples of incorrect code for this rule:

      /*eslint no-useless-concat: "error"*/
      /*eslint-env es6*/
      
      // these are the same as "10"
      var a = `some` + `string`;
      var a = '1' + '0';
      var a = '1' + `0`;
      var a = `1` + '0';
      var a = `1` + `0`;

      Examples of correct code for this rule:

      /*eslint no-useless-concat: "error"*/
      
      // when a non string is included
      var c = a + b;
      var c = '1' + a;
      var a = 1 + '1';
      var c = 1 - 2;
      // when the string concatenation is multiline
      var c = "foo" +
          "bar";

      When Not To Use It

      If you don't want to be notified about unnecessary string concatenation, you can safely disable this rule. Source: http://eslint.org/docs/rules/

      Unexpected string concatenation of literals.
      Open

                  children: [{label: 'offset: ' + '0x' + f.offset.toString(16)}, {label: 'size: ' + f.size}] };
      Severity: Minor
      Found in www/p/lib/js/main.js by eslint

      Disallow unnecessary concatenation of strings (no-useless-concat)

      It's unnecessary to concatenate two strings together, such as:

      var foo = "a" + "b";

      This code is likely the result of refactoring where a variable was removed from the concatenation (such as "a" + b + "b"). In such a case, the concatenation isn't important and the code can be rewritten as:

      var foo = "ab";

      Rule Details

      This rule aims to flag the concatenation of 2 literals when they could be combined into a single literal. Literals can be strings or template literals.

      Examples of incorrect code for this rule:

      /*eslint no-useless-concat: "error"*/
      /*eslint-env es6*/
      
      // these are the same as "10"
      var a = `some` + `string`;
      var a = '1' + '0';
      var a = '1' + `0`;
      var a = `1` + '0';
      var a = `1` + `0`;

      Examples of correct code for this rule:

      /*eslint no-useless-concat: "error"*/
      
      // when a non string is included
      var c = a + b;
      var c = '1' + a;
      var a = 1 + '1';
      var c = 1 - 2;
      // when the string concatenation is multiline
      var c = "foo" +
          "bar";

      When Not To Use It

      If you don't want to be notified about unnecessary string concatenation, you can safely disable this rule. Source: http://eslint.org/docs/rules/

      Unexpected string concatenation of literals.
      Open

                      children: [{label: 'plt: ' + '0x' + f.plt.toString(16)}, {label: 'ord: ' + i}]
      Severity: Minor
      Found in www/p/lib/js/main.js by eslint

      Disallow unnecessary concatenation of strings (no-useless-concat)

      It's unnecessary to concatenate two strings together, such as:

      var foo = "a" + "b";

      This code is likely the result of refactoring where a variable was removed from the concatenation (such as "a" + b + "b"). In such a case, the concatenation isn't important and the code can be rewritten as:

      var foo = "ab";

      Rule Details

      This rule aims to flag the concatenation of 2 literals when they could be combined into a single literal. Literals can be strings or template literals.

      Examples of incorrect code for this rule:

      /*eslint no-useless-concat: "error"*/
      /*eslint-env es6*/
      
      // these are the same as "10"
      var a = `some` + `string`;
      var a = '1' + '0';
      var a = '1' + `0`;
      var a = `1` + '0';
      var a = `1` + `0`;

      Examples of correct code for this rule:

      /*eslint no-useless-concat: "error"*/
      
      // when a non string is included
      var c = a + b;
      var c = '1' + a;
      var a = 1 + '1';
      var c = 1 - 2;
      // when the string concatenation is multiline
      var c = "foo" +
          "bar";

      When Not To Use It

      If you don't want to be notified about unnecessary string concatenation, you can safely disable this rule. Source: http://eslint.org/docs/rules/

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

              center__onresize: function() {if (r2ui._dis.display == 'graph' && r2ui._dis.minimap) update_minimap();},
      Severity: Minor
      Found in www/p/lib/js/main.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/

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

          for (var i in functions) {
      Severity: Minor
      Found in www/p/lib/js/main.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

      Unexpected string concatenation of literals.
      Open

                  label: '<span class=\'flag reloc addr addr_' + '0x' + r.vaddr.toString(16) + '\'>' + r.name + '</span>',
      Severity: Minor
      Found in www/p/lib/js/main.js by eslint

      Disallow unnecessary concatenation of strings (no-useless-concat)

      It's unnecessary to concatenate two strings together, such as:

      var foo = "a" + "b";

      This code is likely the result of refactoring where a variable was removed from the concatenation (such as "a" + b + "b"). In such a case, the concatenation isn't important and the code can be rewritten as:

      var foo = "ab";

      Rule Details

      This rule aims to flag the concatenation of 2 literals when they could be combined into a single literal. Literals can be strings or template literals.

      Examples of incorrect code for this rule:

      /*eslint no-useless-concat: "error"*/
      /*eslint-env es6*/
      
      // these are the same as "10"
      var a = `some` + `string`;
      var a = '1' + '0';
      var a = '1' + `0`;
      var a = `1` + '0';
      var a = `1` + `0`;

      Examples of correct code for this rule:

      /*eslint no-useless-concat: "error"*/
      
      // when a non string is included
      var c = a + b;
      var c = '1' + a;
      var a = 1 + '1';
      var c = 1 - 2;
      // when the string concatenation is multiline
      var c = "foo" +
          "bar";

      When Not To Use It

      If you don't want to be notified about unnecessary string concatenation, you can safely disable this rule. Source: http://eslint.org/docs/rules/

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

                  if (e.keyCode == '38' || e.keyCode == '40') {
      Severity: Minor
      Found in www/p/lib/js/main.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 alert.
      Open

                  alert('Notes won\'t be persited until a project is opened. Use Project\'s tab or \'Ps name\' to save current project');
      Severity: Minor
      Found in www/p/lib/js/main.js by eslint

      Disallow Use of Alert (no-alert)

      JavaScript's alert, confirm, and prompt functions are widely considered to be obtrusive as UI elements and should be replaced by a more appropriate custom UI implementation. Furthermore, alert is often used while debugging code, which should be removed before deployment to production.

      alert("here!");

      Rule Details

      This rule is aimed at catching debugging code that should be removed and popup UI elements that should be replaced with less obtrusive, custom UIs. As such, it will warn when it encounters alert, prompt, and confirm function calls which are not shadowed.

      Examples of incorrect code for this rule:

      /*eslint no-alert: "error"*/
      
      alert("here!");
      
      confirm("Are you sure?");
      
      prompt("What's your name?", "John Doe");

      Examples of correct code for this rule:

      /*eslint no-alert: "error"*/
      
      customAlert("Something happened!");
      
      customConfirm("Are you sure?");
      
      customPrompt("Who are you?");
      
      function foo() {
          var alert = myCustomLib.customAlert;
          alert();
      }

      Related Rules

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

                          xrefs.children[xrefs.children.length] = '<span class=\'xref addr addr_0x' + f.callrefs[j].addr.toString(16)  + '\'>0x' + f.callrefs[j].addr.toString(16) + '</span> (' + (f.callrefs[j].type == 'C' ? 'call' : 'jump') + ')';
      Severity: Minor
      Found in www/p/lib/js/main.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 string concatenation of literals.
      Open

                  label: '<span class=\'flag addr addr_' + '0x' + f.offset.toString(16) + '\'>' + f.name + '</span>',
      Severity: Minor
      Found in www/p/lib/js/main.js by eslint

      Disallow unnecessary concatenation of strings (no-useless-concat)

      It's unnecessary to concatenate two strings together, such as:

      var foo = "a" + "b";

      This code is likely the result of refactoring where a variable was removed from the concatenation (such as "a" + b + "b"). In such a case, the concatenation isn't important and the code can be rewritten as:

      var foo = "ab";

      Rule Details

      This rule aims to flag the concatenation of 2 literals when they could be combined into a single literal. Literals can be strings or template literals.

      Examples of incorrect code for this rule:

      /*eslint no-useless-concat: "error"*/
      /*eslint-env es6*/
      
      // these are the same as "10"
      var a = `some` + `string`;
      var a = '1' + '0';
      var a = '1' + `0`;
      var a = `1` + '0';
      var a = `1` + `0`;

      Examples of correct code for this rule:

      /*eslint no-useless-concat: "error"*/
      
      // when a non string is included
      var c = a + b;
      var c = '1' + a;
      var a = 1 + '1';
      var c = 1 - 2;
      // when the string concatenation is multiline
      var c = "foo" +
          "bar";

      When Not To Use It

      If you don't want to be notified about unnecessary string concatenation, you can safely disable this rule. 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 (var i in sections) {
      Severity: Minor
      Found in www/p/lib/js/main.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: replace with individual fetches of spaces so we can add a class saying what type of flag it is (for renaming)
      Severity: Minor
      Found in www/p/lib/js/main.js by fixme

      TODO found
      Open

          // TODO: replace with individual fetches of spaces so we can add a class saying what type of flag it is (for renaming)
      Severity: Minor
      Found in www/p/lib/js/main.js by fixme

      Similar blocks of code found in 2 locations. Consider refactoring.
      Open

      function render_relocs(relocs) {
          var data = [];
          for (var i in relocs) {
              var r = relocs[i];
              var rd = {
      Severity: Major
      Found in www/p/lib/js/main.js and 1 other location - About 1 day to fix
      www/p/lib/js/main.js on lines 319..333

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 284.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      Similar blocks of code found in 2 locations. Consider refactoring.
      Open

      function render_flags(flags) {
          var data = [];
          for (var i in flags) {
              var f = flags[i];
              var fd = {
      Severity: Major
      Found in www/p/lib/js/main.js and 1 other location - About 1 day to fix
      www/p/lib/js/main.js on lines 304..318

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 284.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      Identical blocks of code found in 2 locations. Consider refactoring.
      Open

          $('#command').keydown(function(inEvent) {
              var key = inEvent.keyCode || inEvent.charCode || inEvent.which || 0;
              if (key === 40) {
                  console_history_idx++;
                  if (console_history_idx > console_history.length - 1) console_history_idx = console_history.length;
      Severity: Major
      Found in www/p/lib/js/main.js and 1 other location - About 7 hrs to fix
      www/enyo/js/disassembler.js on lines 536..548

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 191.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      Identical blocks of code found in 2 locations. Consider refactoring.
      Open

                      if (r2ui.console_lang == 'r2') {
                          r2.cmd(inColor(cmd), function(x) {
                              var old_value = $('#cmd_output').text();
                              $('#cmd_output').html(old_value + '\n> ' + cmd + '\n' + x);
                              $('#cmd_output').scrollTo($('#cmd_output')[0].scrollHeight);
      Severity: Major
      Found in www/p/lib/js/main.js and 1 other location - About 5 hrs to fix
      www/enyo/js/disassembler.js on lines 516..525

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 140.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      There are no issues that match your filters.

      Category
      Status