haraka/haraka-plugin-known-senders

View on GitHub

Showing 5 of 5 total issues

Function is_dkim_authenticated has 45 lines of code (exceeds 25 allowed). Consider refactoring.
Open

exports.is_dkim_authenticated = async function (next, connection) {
  const plugin = this
  if (connection.relaying) return next();

  let rcpt_ods = [];
Severity: Minor
Found in index.js - About 1 hr to fix

    Function is_dkim_authenticated has a Cognitive Complexity of 17 (exceeds 10 allowed). Consider refactoring.
    Open

    exports.is_dkim_authenticated = async function (next, connection) {
      const plugin = this
      if (connection.relaying) return next();
    
      let rcpt_ods = [];
    Severity: Minor
    Found in index.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

    Function update_sender has 31 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    exports.update_sender = async function (next, connection, params) {
      // queue_ok arguments: next, connection, msg
      // ok 1390590369 qp 634 (F82E2DD5-9238-41DC-BC95-9C3A02716AD2.1)
    
      let sender_od;
    Severity: Minor
    Found in index.js - About 1 hr to fix

      'params' is defined but never used.
      Open

      exports.update_sender = async function (next, connection, params) {
      Severity: Minor
      Found in index.js by eslint

      no-unused-vars

      Disallows unused variables.

      Variables that are declared and not used anywhere in the code are most likely an error due to incomplete refactoring. Such variables take up space in the code and can lead to confusion by readers.

      Rule Details

      This rule is aimed at eliminating unused variables, functions, and function parameters.

      A variable foo is considered to be used if any of the following are true:

      • It is called (foo()) or constructed (new foo())
      • It is read (var bar = foo)
      • It is passed into a function as an argument (doSomething(foo))
      • It is read inside of a function that is passed to another function (doSomething(function() { foo(); }))

      A variable is not considered to be used if it is only ever declared (var foo = 5) or assigned to (foo = 7).

      Examples of incorrect code for this rule:

      /*eslint no-unused-vars: "error"*/
      /*global some_unused_var*/
      
      // It checks variables you have defined as global
      some_unused_var = 42;
      
      var x;
      
      // Write-only variables are not considered as used.
      var y = 10;
      y = 5;
      
      // A read for a modification of itself is not considered as used.
      var z = 0;
      z = z + 1;
      
      // By default, unused arguments cause warnings.
      (function(foo) {
          return 5;
      })();
      
      // Unused recursive functions also cause warnings.
      function fact(n) {
          if (n < 2) return 1;
          return n * fact(n - 1);
      }
      
      // When a function definition destructures an array, unused entries from the array also cause warnings.
      function getY([x, y]) {
          return y;
      }

      Examples of correct code for this rule:

      /*eslint no-unused-vars: "error"*/
      
      var x = 10;
      alert(x);
      
      // foo is considered used here
      myFunc(function foo() {
          // ...
      }.bind(this));
      
      (function(foo) {
          return foo;
      })();
      
      var myFunc;
      myFunc = setTimeout(function() {
          // myFunc is considered used
          myFunc();
      }, 50);
      
      // Only the second argument from the destructured array is used.
      function getY([, y]) {
          return y;
      }

      exported

      In environments outside of CommonJS or ECMAScript modules, you may use var to create a global variable that may be used by other scripts. You can use the /* exported variableName */ comment block to indicate that this variable is being exported and therefore should not be considered unused.

      Note that /* exported */ has no effect for any of the following:

      • when the environment is node or commonjs
      • when parserOptions.sourceType is module
      • when ecmaFeatures.globalReturn is true

      The line comment // exported variableName will not work as exported is not line-specific.

      Examples of correct code for /* exported variableName */ operation:

      /* exported global_var */
      
      var global_var = 42;

      Options

      This rule takes one argument which can be a string or an object. The string settings are the same as those of the vars property (explained below).

      By default this rule is enabled with all option for variables and after-used for arguments.

      {
          "rules": {
              "no-unused-vars": ["error", { "vars": "all", "args": "after-used", "ignoreRestSiblings": false }]
          }
      }

      vars

      The vars option has two settings:

      • all checks all variables for usage, including those in the global scope. This is the default setting.
      • local checks only that locally-declared variables are used but will allow global variables to be unused.

      vars: local

      Examples of correct code for the { "vars": "local" } option:

      /*eslint no-unused-vars: ["error", { "vars": "local" }]*/
      /*global some_unused_var */
      
      some_unused_var = 42;

      varsIgnorePattern

      The varsIgnorePattern option specifies exceptions not to check for usage: variables whose names match a regexp pattern. For example, variables whose names contain ignored or Ignored.

      Examples of correct code for the { "varsIgnorePattern": "[iI]gnored" } option:

      /*eslint no-unused-vars: ["error", { "varsIgnorePattern": "[iI]gnored" }]*/
      
      var firstVarIgnored = 1;
      var secondVar = 2;
      console.log(secondVar);

      args

      The args option has three settings:

      • after-used - unused positional arguments that occur before the last used argument will not be checked, but all named arguments and all positional arguments after the last used argument will be checked.
      • all - all named arguments must be used.
      • none - do not check arguments.

      args: after-used

      Examples of incorrect code for the default { "args": "after-used" } option:

      /*eslint no-unused-vars: ["error", { "args": "after-used" }]*/
      
      // 2 errors, for the parameters after the last used parameter (bar)
      // "baz" is defined but never used
      // "qux" is defined but never used
      (function(foo, bar, baz, qux) {
          return bar;
      })();

      Examples of correct code for the default { "args": "after-used" } option:

      /*eslint no-unused-vars: ["error", {"args": "after-used"}]*/
      
      (function(foo, bar, baz, qux) {
          return qux;
      })();

      args: all

      Examples of incorrect code for the { "args": "all" } option:

      /*eslint no-unused-vars: ["error", { "args": "all" }]*/
      
      // 2 errors
      // "foo" is defined but never used
      // "baz" is defined but never used
      (function(foo, bar, baz) {
          return bar;
      })();

      args: none

      Examples of correct code for the { "args": "none" } option:

      /*eslint no-unused-vars: ["error", { "args": "none" }]*/
      
      (function(foo, bar, baz) {
          return bar;
      })();

      ignoreRestSiblings

      The ignoreRestSiblings option is a boolean (default: false). Using a Rest Property it is possible to "omit" properties from an object, but by default the sibling properties are marked as "unused". With this option enabled the rest property's siblings are ignored.

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

      /*eslint no-unused-vars: ["error", { "ignoreRestSiblings": true }]*/
      // 'foo' and 'bar' were ignored because they have a rest property sibling.
      var { foo, ...coords } = data;
      
      var bar;
      ({ bar, ...coords } = data);

      argsIgnorePattern

      The argsIgnorePattern option specifies exceptions not to check for usage: arguments whose names match a regexp pattern. For example, variables whose names begin with an underscore.

      Examples of correct code for the { "argsIgnorePattern": "^_" } option:

      /*eslint no-unused-vars: ["error", { "argsIgnorePattern": "^_" }]*/
      
      function foo(x, _y) {
          return x + 1;
      }
      foo();

      caughtErrors

      The caughtErrors option is used for catch block arguments validation.

      It has two settings:

      • none - do not check error objects. This is the default setting.
      • all - all named arguments must be used.

      caughtErrors: none

      Not specifying this rule is equivalent of assigning it to none.

      Examples of correct code for the { "caughtErrors": "none" } option:

      /*eslint no-unused-vars: ["error", { "caughtErrors": "none" }]*/
      
      try {
          //...
      } catch (err) {
          console.error("errors");
      }

      caughtErrors: all

      Examples of incorrect code for the { "caughtErrors": "all" } option:

      /*eslint no-unused-vars: ["error", { "caughtErrors": "all" }]*/
      
      // 1 error
      // "err" is defined but never used
      try {
          //...
      } catch (err) {
          console.error("errors");
      }

      caughtErrorsIgnorePattern

      The caughtErrorsIgnorePattern option specifies exceptions not to check for usage: catch arguments whose names match a regexp pattern. For example, variables whose names begin with a string 'ignore'.

      Examples of correct code for the { "caughtErrorsIgnorePattern": "^ignore" } option:

      /*eslint no-unused-vars: ["error", { "caughtErrorsIgnorePattern": "^ignore" }]*/
      
      try {
          //...
      } catch (ignoreErr) {
          console.error("errors");
      }

      When Not To Use It

      If you don't want to be notified about unused variables or function arguments, you can safely turn this rule off. Source: http://eslint.org/docs/rules/

      'params' is defined but never used.
      Open

      exports.is_authenticated = function (next, connection, params) {
      Severity: Minor
      Found in index.js by eslint

      no-unused-vars

      Disallows unused variables.

      Variables that are declared and not used anywhere in the code are most likely an error due to incomplete refactoring. Such variables take up space in the code and can lead to confusion by readers.

      Rule Details

      This rule is aimed at eliminating unused variables, functions, and function parameters.

      A variable foo is considered to be used if any of the following are true:

      • It is called (foo()) or constructed (new foo())
      • It is read (var bar = foo)
      • It is passed into a function as an argument (doSomething(foo))
      • It is read inside of a function that is passed to another function (doSomething(function() { foo(); }))

      A variable is not considered to be used if it is only ever declared (var foo = 5) or assigned to (foo = 7).

      Examples of incorrect code for this rule:

      /*eslint no-unused-vars: "error"*/
      /*global some_unused_var*/
      
      // It checks variables you have defined as global
      some_unused_var = 42;
      
      var x;
      
      // Write-only variables are not considered as used.
      var y = 10;
      y = 5;
      
      // A read for a modification of itself is not considered as used.
      var z = 0;
      z = z + 1;
      
      // By default, unused arguments cause warnings.
      (function(foo) {
          return 5;
      })();
      
      // Unused recursive functions also cause warnings.
      function fact(n) {
          if (n < 2) return 1;
          return n * fact(n - 1);
      }
      
      // When a function definition destructures an array, unused entries from the array also cause warnings.
      function getY([x, y]) {
          return y;
      }

      Examples of correct code for this rule:

      /*eslint no-unused-vars: "error"*/
      
      var x = 10;
      alert(x);
      
      // foo is considered used here
      myFunc(function foo() {
          // ...
      }.bind(this));
      
      (function(foo) {
          return foo;
      })();
      
      var myFunc;
      myFunc = setTimeout(function() {
          // myFunc is considered used
          myFunc();
      }, 50);
      
      // Only the second argument from the destructured array is used.
      function getY([, y]) {
          return y;
      }

      exported

      In environments outside of CommonJS or ECMAScript modules, you may use var to create a global variable that may be used by other scripts. You can use the /* exported variableName */ comment block to indicate that this variable is being exported and therefore should not be considered unused.

      Note that /* exported */ has no effect for any of the following:

      • when the environment is node or commonjs
      • when parserOptions.sourceType is module
      • when ecmaFeatures.globalReturn is true

      The line comment // exported variableName will not work as exported is not line-specific.

      Examples of correct code for /* exported variableName */ operation:

      /* exported global_var */
      
      var global_var = 42;

      Options

      This rule takes one argument which can be a string or an object. The string settings are the same as those of the vars property (explained below).

      By default this rule is enabled with all option for variables and after-used for arguments.

      {
          "rules": {
              "no-unused-vars": ["error", { "vars": "all", "args": "after-used", "ignoreRestSiblings": false }]
          }
      }

      vars

      The vars option has two settings:

      • all checks all variables for usage, including those in the global scope. This is the default setting.
      • local checks only that locally-declared variables are used but will allow global variables to be unused.

      vars: local

      Examples of correct code for the { "vars": "local" } option:

      /*eslint no-unused-vars: ["error", { "vars": "local" }]*/
      /*global some_unused_var */
      
      some_unused_var = 42;

      varsIgnorePattern

      The varsIgnorePattern option specifies exceptions not to check for usage: variables whose names match a regexp pattern. For example, variables whose names contain ignored or Ignored.

      Examples of correct code for the { "varsIgnorePattern": "[iI]gnored" } option:

      /*eslint no-unused-vars: ["error", { "varsIgnorePattern": "[iI]gnored" }]*/
      
      var firstVarIgnored = 1;
      var secondVar = 2;
      console.log(secondVar);

      args

      The args option has three settings:

      • after-used - unused positional arguments that occur before the last used argument will not be checked, but all named arguments and all positional arguments after the last used argument will be checked.
      • all - all named arguments must be used.
      • none - do not check arguments.

      args: after-used

      Examples of incorrect code for the default { "args": "after-used" } option:

      /*eslint no-unused-vars: ["error", { "args": "after-used" }]*/
      
      // 2 errors, for the parameters after the last used parameter (bar)
      // "baz" is defined but never used
      // "qux" is defined but never used
      (function(foo, bar, baz, qux) {
          return bar;
      })();

      Examples of correct code for the default { "args": "after-used" } option:

      /*eslint no-unused-vars: ["error", {"args": "after-used"}]*/
      
      (function(foo, bar, baz, qux) {
          return qux;
      })();

      args: all

      Examples of incorrect code for the { "args": "all" } option:

      /*eslint no-unused-vars: ["error", { "args": "all" }]*/
      
      // 2 errors
      // "foo" is defined but never used
      // "baz" is defined but never used
      (function(foo, bar, baz) {
          return bar;
      })();

      args: none

      Examples of correct code for the { "args": "none" } option:

      /*eslint no-unused-vars: ["error", { "args": "none" }]*/
      
      (function(foo, bar, baz) {
          return bar;
      })();

      ignoreRestSiblings

      The ignoreRestSiblings option is a boolean (default: false). Using a Rest Property it is possible to "omit" properties from an object, but by default the sibling properties are marked as "unused". With this option enabled the rest property's siblings are ignored.

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

      /*eslint no-unused-vars: ["error", { "ignoreRestSiblings": true }]*/
      // 'foo' and 'bar' were ignored because they have a rest property sibling.
      var { foo, ...coords } = data;
      
      var bar;
      ({ bar, ...coords } = data);

      argsIgnorePattern

      The argsIgnorePattern option specifies exceptions not to check for usage: arguments whose names match a regexp pattern. For example, variables whose names begin with an underscore.

      Examples of correct code for the { "argsIgnorePattern": "^_" } option:

      /*eslint no-unused-vars: ["error", { "argsIgnorePattern": "^_" }]*/
      
      function foo(x, _y) {
          return x + 1;
      }
      foo();

      caughtErrors

      The caughtErrors option is used for catch block arguments validation.

      It has two settings:

      • none - do not check error objects. This is the default setting.
      • all - all named arguments must be used.

      caughtErrors: none

      Not specifying this rule is equivalent of assigning it to none.

      Examples of correct code for the { "caughtErrors": "none" } option:

      /*eslint no-unused-vars: ["error", { "caughtErrors": "none" }]*/
      
      try {
          //...
      } catch (err) {
          console.error("errors");
      }

      caughtErrors: all

      Examples of incorrect code for the { "caughtErrors": "all" } option:

      /*eslint no-unused-vars: ["error", { "caughtErrors": "all" }]*/
      
      // 1 error
      // "err" is defined but never used
      try {
          //...
      } catch (err) {
          console.error("errors");
      }

      caughtErrorsIgnorePattern

      The caughtErrorsIgnorePattern option specifies exceptions not to check for usage: catch arguments whose names match a regexp pattern. For example, variables whose names begin with a string 'ignore'.

      Examples of correct code for the { "caughtErrorsIgnorePattern": "^ignore" } option:

      /*eslint no-unused-vars: ["error", { "caughtErrorsIgnorePattern": "^ignore" }]*/
      
      try {
          //...
      } catch (ignoreErr) {
          console.error("errors");
      }

      When Not To Use It

      If you don't want to be notified about unused variables or function arguments, you can safely turn this rule off. Source: http://eslint.org/docs/rules/

      Severity
      Category
      Status
      Source
      Language