radare/radare2-webui

View on GitHub
www/t/js/main.js

Summary

Maintainability
F
1 wk
Test Coverage

Function onload has 507 lines of code (exceeds 25 allowed). Consider refactoring.
Open

window.onload = function () {
  var position = 'right';
  var t = new Tiled('canvas');
  var ctr = 0;
  r2.cmd('e scr.color=3;eco sepia;e scr.html=true', function () {
Severity: Major
Found in www/t/js/main.js - About 2 days to fix

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

    
    function findPos (obj) {
      var curtop = 0;
      var curleft = 0;
      if (obj.offsetParent) {
    Severity: Major
    Found in www/t/js/main.js - About 1 day to fix

      Function onload has a Cognitive Complexity of 35 (exceeds 5 allowed). Consider refactoring.
      Open

      window.onload = function () {
        var position = 'right';
        var t = new Tiled('canvas');
        var ctr = 0;
        r2.cmd('e scr.color=3;eco sepia;e scr.html=true', function () {
      Severity: Minor
      Found in www/t/js/main.js - About 5 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 a complexity of 25.
      Open

        document.onkeydown = function (evt) {
      Severity: Minor
      Found in www/t/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 21.
      Open

        _('body').onkeyup = function (e) {
      Severity: Minor
      Found in www/t/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 newHexdumpFrame has 75 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        function newHexdumpFrame () {
          var n = t.defname('hexdump');
          var msgbody = '<div id=\'' + n + '_hexdump\' class=\'frame_body\'></div>';
          t.new_frame(n, msgbody, function (obj) {
            var code = _(n + 'code');
      Severity: Major
      Found in www/t/js/main.js - About 3 hrs to fix

        Function newDisasmFrame has 74 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          function newDisasmFrame () {
            var n = t.defname('disas');
            var disasmbody = '<div id=\'' + n + '_code\' class=\'frame_body\'></div>';
            t.new_frame(n, disasmbody, function (obj) {
              var code = _(n + '_code');
        Severity: Major
        Found in www/t/js/main.js - About 2 hrs to fix

          Function newDebugFrame has 70 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            function newDebugFrame () {
              var name = 'debug';
              var n = t.defname(name);
              var fillFrame = function () {
                // TODO: list breakpoints with `dbj`
          Severity: Major
          Found in www/t/js/main.js - About 2 hrs to fix

            Function onkeydown has 54 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

              document.onkeydown = function (evt) {
                evt = evt || window.event;
                var isEscape = false;
                if ('key' in evt) {
                  isEscape = (evt.key === 'Escape' || evt.key === 'Esc');
            Severity: Major
            Found in www/t/js/main.js - About 2 hrs to fix

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

              window.onload = function () {
              Severity: Minor
              Found in www/t/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 fillFrame has 49 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  var fillFrame = function () {
                    // TODO: list breakpoints with `dbj`
                    r2.cmdj('drj', function (regs) {
                      r2.cmd('pxQ@rsp', function (pxQ) {
                        r2.cmd('dbt', function (dbt) {
              Severity: Minor
              Found in www/t/js/main.js - About 1 hr to fix

                Function calc has 46 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                      function calc (addr) {
                        if (addr) {
                          frame.offset = addr;
                        }
                        var off = frame.offset || '0';
                Severity: Minor
                Found in www/t/js/main.js - About 1 hr to fix

                  Function onkeyup has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                    _('body').onkeyup = function (e) {
                      if (t.modal) {
                        return;
                      }
                      var key = String.fromCharCode(e.keyCode);
                  Severity: Minor
                  Found in www/t/js/main.js - About 1 hr to fix

                    Function newHelpFrame has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                      function newHelpFrame () {
                        var n = t.defname('help');
                        function newthing (name) {
                          // TODO: disas_code id
                          setTimeout(function () {
                    Severity: Minor
                    Found in www/t/js/main.js - About 1 hr to fix

                      Unexpected prompt.
                      Open

                            t.cmd = prompt();
                      Severity: Minor
                      Found in www/t/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

                      'body' is already defined.
                      Open

                                var body = modalAssembler();
                      Severity: Minor
                      Found in www/t/js/main.js by eslint

                      disallow variable redeclaration (no-redeclare)

                      In JavaScript, it's possible to redeclare the same variable name using var. This can lead to confusion as to where the variable is actually declared and initialized.

                      Rule Details

                      This rule is aimed at eliminating variables that have multiple declarations in the same scope.

                      Examples of incorrect code for this rule:

                      /*eslint no-redeclare: "error"*/
                      
                      var a = 3;
                      var a = 10;

                      Examples of correct code for this rule:

                      /*eslint no-redeclare: "error"*/
                      
                      var a = 3;
                      // ...
                      a = 10;

                      Options

                      This rule takes one optional argument, an object with a boolean property "builtinGlobals". It defaults to false. If set to true, this rule also checks redeclaration of built-in globals, such as Object, Array, Number...

                      builtinGlobals

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

                      /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
                      
                      var Object = 0;

                      Examples of incorrect code for the { "builtinGlobals": true } option and the browser environment:

                      /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
                      /*eslint-env browser*/
                      
                      var top = 0;

                      The browser environment has many built-in global variables (for example, top). Some of built-in global variables cannot be redeclared. Source: http://eslint.org/docs/rules/

                      Empty block statement.
                      Open

                            } catch (e) {
                      Severity: Minor
                      Found in www/t/js/main.js by eslint

                      disallow empty block statements (no-empty)

                      Empty block statements, while not technically errors, usually occur due to refactoring that wasn't completed. They can cause confusion when reading code.

                      Rule Details

                      This rule disallows empty block statements. This rule ignores block statements which contain a comment (for example, in an empty catch or finally block of a try statement to indicate that execution should continue regardless of errors).

                      Examples of incorrect code for this rule:

                      /*eslint no-empty: "error"*/
                      
                      if (foo) {
                      }
                      
                      while (foo) {
                      }
                      
                      switch(foo) {
                      }
                      
                      try {
                          doSomething();
                      } catch(ex) {
                      
                      } finally {
                      
                      }

                      Examples of correct code for this rule:

                      /*eslint no-empty: "error"*/
                      
                      if (foo) {
                          // empty
                      }
                      
                      while (foo) {
                          /* empty */
                      }
                      
                      try {
                          doSomething();
                      } catch (ex) {
                          // continue regardless of error
                      }
                      
                      try {
                          doSomething();
                      } finally {
                          /* continue regardless of error */
                      }

                      Options

                      This rule has an object option for exceptions:

                      • "allowEmptyCatch": true allows empty catch clauses (that is, which do not contain a comment)

                      allowEmptyCatch

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

                      /* eslint no-empty: ["error", { "allowEmptyCatch": true }] */
                      try {
                          doSomething();
                      } catch (ex) {}
                      
                      try {
                          doSomething();
                      }
                      catch (ex) {}
                      finally {
                          /* continue regardless of error */
                      }

                      When Not To Use It

                      If you intentionally use empty block statements then you can disable this rule.

                      Related Rules

                      'body' is already defined.
                      Open

                                var body = modalShell();
                      Severity: Minor
                      Found in www/t/js/main.js by eslint

                      disallow variable redeclaration (no-redeclare)

                      In JavaScript, it's possible to redeclare the same variable name using var. This can lead to confusion as to where the variable is actually declared and initialized.

                      Rule Details

                      This rule is aimed at eliminating variables that have multiple declarations in the same scope.

                      Examples of incorrect code for this rule:

                      /*eslint no-redeclare: "error"*/
                      
                      var a = 3;
                      var a = 10;

                      Examples of correct code for this rule:

                      /*eslint no-redeclare: "error"*/
                      
                      var a = 3;
                      // ...
                      a = 10;

                      Options

                      This rule takes one optional argument, an object with a boolean property "builtinGlobals". It defaults to false. If set to true, this rule also checks redeclaration of built-in globals, such as Object, Array, Number...

                      builtinGlobals

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

                      /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
                      
                      var Object = 0;

                      Examples of incorrect code for the { "builtinGlobals": true } option and the browser environment:

                      /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
                      /*eslint-env browser*/
                      
                      var top = 0;

                      The browser environment has many built-in global variables (for example, top). Some of built-in global variables cannot be redeclared. Source: http://eslint.org/docs/rules/

                      Unexpected prompt.
                      Open

                                    var newoff = prompt('Goto');
                      Severity: Minor
                      Found in www/t/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

                      Unexpected prompt.
                      Open

                                  var newoff = prompt('Goto');
                      Severity: Minor
                      Found in www/t/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

                      Unexpected alert.
                      Open

                              r2.cmd('pi 2', function (x) { alert(x); });
                      Severity: Minor
                      Found in www/t/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

                      Unexpected alert.
                      Open

                              r2.cmd(prompt('Command to execute'), function (x) { alert(x); });
                      Severity: Minor
                      Found in www/t/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

                      Unexpected prompt.
                      Open

                                        var until = prompt('Until');
                      Severity: Minor
                      Found in www/t/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

                      'q' is already defined.
                      Open

                                  var q = document.getElementById(id_goto);
                      Severity: Minor
                      Found in www/t/js/main.js by eslint

                      disallow variable redeclaration (no-redeclare)

                      In JavaScript, it's possible to redeclare the same variable name using var. This can lead to confusion as to where the variable is actually declared and initialized.

                      Rule Details

                      This rule is aimed at eliminating variables that have multiple declarations in the same scope.

                      Examples of incorrect code for this rule:

                      /*eslint no-redeclare: "error"*/
                      
                      var a = 3;
                      var a = 10;

                      Examples of correct code for this rule:

                      /*eslint no-redeclare: "error"*/
                      
                      var a = 3;
                      // ...
                      a = 10;

                      Options

                      This rule takes one optional argument, an object with a boolean property "builtinGlobals". It defaults to false. If set to true, this rule also checks redeclaration of built-in globals, such as Object, Array, Number...

                      builtinGlobals

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

                      /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
                      
                      var Object = 0;

                      Examples of incorrect code for the { "builtinGlobals": true } option and the browser environment:

                      /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
                      /*eslint-env browser*/
                      
                      var top = 0;

                      The browser environment has many built-in global variables (for example, top). Some of built-in global variables cannot be redeclared. 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 r in regs) {
                      Severity: Minor
                      Found in www/t/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 prompt.
                      Open

                            t.cmd = prompt();
                      Severity: Minor
                      Found in www/t/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

                      Unreachable code.
                      Open

                              break;
                      Severity: Minor
                      Found in www/t/js/main.js by eslint

                      disallow unreachable code after return, throw, continue, and break statements (no-unreachable)

                      Because the return, throw, break, and continue statements unconditionally exit a block of code, any statements after them cannot be executed. Unreachable statements are usually a mistake.

                      function fn() {
                          x = 1;
                          return x;
                          x = 3; // this will never execute
                      }

                      Rule Details

                      This rule disallows unreachable code after return, throw, continue, and break statements.

                      Examples of incorrect code for this rule:

                      /*eslint no-unreachable: "error"*/
                      
                      function foo() {
                          return true;
                          console.log("done");
                      }
                      
                      function bar() {
                          throw new Error("Oops!");
                          console.log("done");
                      }
                      
                      while(value) {
                          break;
                          console.log("done");
                      }
                      
                      throw new Error("Oops!");
                      console.log("done");
                      
                      function baz() {
                          if (Math.random() < 0.5) {
                              return;
                          } else {
                              throw new Error();
                          }
                          console.log("done");
                      }
                      
                      for (;;) {}
                      console.log("done");

                      Examples of correct code for this rule, because of JavaScript function and variable hoisting:

                      /*eslint no-unreachable: "error"*/
                      
                      function foo() {
                          return bar();
                          function bar() {
                              return 1;
                          }
                      }
                      
                      function bar() {
                          return x;
                          var x;
                      }
                      
                      switch (foo) {
                          case 1:
                              break;
                              var x;
                      }

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

                      Unexpected prompt.
                      Open

                              r2.cmd(prompt('Command to execute'), function (x) { alert(x); });
                      Severity: Minor
                      Found in www/t/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

                      TODO found
                      Open

                            // TODO: disas_code id
                      Severity: Minor
                      Found in www/t/js/main.js by fixme

                      TODO found
                      Open

                                  r2.cmd('dm', function (maps) { // TODO: use dmj
                      Severity: Minor
                      Found in www/t/js/main.js by fixme

                      TODO found
                      Open

                            // TODO: disas_code id
                      Severity: Minor
                      Found in www/t/js/main.js by fixme

                      TODO found
                      Open

                            // TODO: list breakpoints with `dbj`
                      Severity: Minor
                      Found in www/t/js/main.js by fixme

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

                          t.new_frame(n, newthing(n), function (obj) {
                            var flags = _(n + '_console');
                            if (flags) {
                              var top = flags.style.offsetTop;
                              var pos = findPos(flags);
                      Severity: Major
                      Found in www/t/js/main.js and 5 other locations - About 4 hrs to fix
                      www/t/js/main.js on lines 136..144
                      www/t/js/main.js on lines 233..241
                      www/t/js/main.js on lines 260..268
                      www/t/js/main.js on lines 273..281
                      www/t/js/main.js on lines 352..360

                      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 117.

                      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 6 locations. Consider refactoring.
                      Open

                          t.new_frame(n, newthing(n), function (obj) {
                            var flags = _(n + '_flags');
                            if (flags) {
                              var top = flags.style.offsetTop;
                              var pos = findPos(flags);
                      Severity: Major
                      Found in www/t/js/main.js and 5 other locations - About 4 hrs to fix
                      www/t/js/main.js on lines 136..144
                      www/t/js/main.js on lines 154..162
                      www/t/js/main.js on lines 233..241
                      www/t/js/main.js on lines 273..281
                      www/t/js/main.js on lines 352..360

                      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 117.

                      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 6 locations. Consider refactoring.
                      Open

                          t.new_frame(n, msgbody, function (obj) {
                            var code = _(n + 'code');
                            if (code) {
                              var top = code.style.offsetTop;
                              var pos = findPos(code);
                      Severity: Major
                      Found in www/t/js/main.js and 5 other locations - About 4 hrs to fix
                      www/t/js/main.js on lines 136..144
                      www/t/js/main.js on lines 154..162
                      www/t/js/main.js on lines 233..241
                      www/t/js/main.js on lines 260..268
                      www/t/js/main.js on lines 352..360

                      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 117.

                      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 6 locations. Consider refactoring.
                      Open

                          t.new_frame(n, newthing(n), function (obj) {
                            var flags = _(n + '_help');
                            if (flags) {
                              var top = flags.style.offsetTop;
                              var pos = findPos(flags);
                      Severity: Major
                      Found in www/t/js/main.js and 5 other locations - About 4 hrs to fix
                      www/t/js/main.js on lines 154..162
                      www/t/js/main.js on lines 233..241
                      www/t/js/main.js on lines 260..268
                      www/t/js/main.js on lines 273..281
                      www/t/js/main.js on lines 352..360

                      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 117.

                      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 6 locations. Consider refactoring.
                      Open

                          t.new_frame(n, newthing(n), function (obj) {
                            var flags = _(n + '_frame');
                            if (flags) {
                              var top = flags.style.offsetTop;
                              var pos = findPos(flags);
                      Severity: Major
                      Found in www/t/js/main.js and 5 other locations - About 4 hrs to fix
                      www/t/js/main.js on lines 136..144
                      www/t/js/main.js on lines 154..162
                      www/t/js/main.js on lines 260..268
                      www/t/js/main.js on lines 273..281
                      www/t/js/main.js on lines 352..360

                      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 117.

                      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 6 locations. Consider refactoring.
                      Open

                          t.new_frame(n, disasmbody, function (obj) {
                            var code = _(n + '_notes');
                            if (code) {
                              var top = code.style.offsetTop;
                              var pos = findPos(code);
                      Severity: Major
                      Found in www/t/js/main.js and 5 other locations - About 4 hrs to fix
                      www/t/js/main.js on lines 136..144
                      www/t/js/main.js on lines 154..162
                      www/t/js/main.js on lines 233..241
                      www/t/js/main.js on lines 260..268
                      www/t/js/main.js on lines 273..281

                      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 117.

                      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

                          t.new_frame(n, disasmbody, function (obj) {
                            var code = _(n + '_code');
                            if (code) {
                              var top = code.style.offsetTop;
                              var pos = findPos(code);
                      Severity: Major
                      Found in www/t/js/main.js and 1 other location - About 3 hrs to fix
                      www/t/js/main.js on lines 369..377

                      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 105.

                      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

                          t.new_frame(n, settbody, function (obj) {
                            var code = _(n + '_settings');
                            if (code) {
                              var top = code.style.offsetTop;
                              var pos = findPos(code);
                      Severity: Major
                      Found in www/t/js/main.js and 1 other location - About 3 hrs to fix
                      www/t/js/main.js on lines 386..394

                      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 105.

                      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

                                  Q.onclick = function () {
                                    r2.cmd('s+512;s', function (res) {
                                      frame.offset = res.trim();
                                      calc();
                                      frame.refresh();
                      Severity: Major
                      Found in www/t/js/main.js and 1 other location - About 1 hr to fix
                      www/t/js/main.js on lines 310..316

                      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 68.

                      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

                                  q.onclick = function () {
                                    r2.cmd('s-512;s', function (res) {
                                      frame.offset = res.trim();
                                      calc();
                                      frame.refresh();
                      Severity: Major
                      Found in www/t/js/main.js and 1 other location - About 1 hr to fix
                      www/t/js/main.js on lines 318..324

                      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 68.

                      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

                                _(n + '_code').innerHTML = seekbar +
                                '<br /><center><a class=link href=\'#\' id=' + idPrev + '>[PREV]</a>' +
                                '<a class=link href=\'#\' id=' + id_goto + '>[GOTO]</a>' +
                                '<a class=link href=\'#\' id=' + idNext + '>[NEXT]</a></center>' +
                                '<pre>' + x + '</pre>';
                      Severity: Major
                      Found in www/t/js/main.js and 1 other location - About 1 hr to fix
                      www/t/js/main.js on lines 302..307

                      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 66.

                      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

                                  _(n + '_hexdump').innerHTML = seekbar +
                            '<br /><center><a class=link href=\'#\' id=' + idPrev + '>[PREV]</a>' +
                            '<a class=link href=\'#\' id=' + id_goto + '>[GOTO]</a>' +
                            '<a class=link href=\'#\' id=' + idNext + '>[NEXT]</a></center>' +
                            '<pre>' + x + '</pre>'
                      Severity: Major
                      Found in www/t/js/main.js and 1 other location - About 1 hr to fix
                      www/t/js/main.js on lines 418..422

                      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 66.

                      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

                          _('cmd_' + ctr).onclick = function () {
                            t.key = 'div_' + ctr;
                            t.cmd = prompt();
                            t.update();
                          };
                      Severity: Major
                      Found in www/t/js/main.js and 1 other location - About 1 hr to fix
                      www/t/js/main.js on lines 504..508

                      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 63.

                      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

                          _('cmd_' + ctr).onclick = function () {
                            t.key = 'div_' + ctr;
                            t.cmd = prompt();
                            t.update();
                          };
                      Severity: Major
                      Found in www/t/js/main.js and 1 other location - About 1 hr to fix
                      www/t/js/main.js on lines 472..476

                      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 63.

                      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

                                q2.onclick = function () {
                                  r2.cmd('s+512;s', function (res) {
                                    frame.offset = res.trim();
                                    frame.refresh();
                                  });
                      Severity: Major
                      Found in www/t/js/main.js and 1 other location - About 1 hr to fix
                      www/t/js/main.js on lines 424..429

                      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 62.

                      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

                                q.onclick = function () {
                                  r2.cmd('s-512;s', function (res) {
                                    frame.offset = res.trim();
                                    frame.refresh();
                                  });
                      Severity: Major
                      Found in www/t/js/main.js and 1 other location - About 1 hr to fix
                      www/t/js/main.js on lines 431..436

                      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 62.

                      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