Sign upLogin

tenon-io/tenon-cli

View on GitHub
Star
tenon-cli.js

Summary

Maintainability
D
2 days
Test Coverage

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

  const parseFormat = (json) => {
    switch (allOptions.format) {
      case 'json':
        // Tenon returns resuls in JSON, so it's already formatted correctly
        return new Promise((resolve) => {
Severity: Minor
Found in tenon-cli.js - About 1 hr to fix

    Unexpected console statement.
    Open

            console.error(JSON.stringify(result, null, '\t'));
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

              console.log('Writing results to file...');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

          console.error('Failed to parse or read configuration file...');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

          console.log('Tenon analysis completed.');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

          console.log('\'' + field + '\' is required');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

        console.error('No input HTML specified for analysis');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

          console.error('Failed to read input file, ' + allOptions.in);
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

            console.error('Tenon reported an error:');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

                  console.error(err);
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

              console.log('Writing results to console...');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

          console.error(e.message);
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

                console.error('Failed to write result to file...');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

          console.log(`Analysis complete, report at ${file}`);
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

                  console.error('Failed to parse Tenon response into HTML format');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

            console.error('Error occured, format not found');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

        console.error('You have supplied too many arguments, for help type \'tenon --help\'');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

                console.error(e.message);
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

                  console.error('Failed to parse Tenon response into XUnit format');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unreachable code.
    Open

            break;
    Severity: Minor
    Found in tenon-cli.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 console statement.
    Open

      console.log('Sending request to Tenon...');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

                  console.error(err);
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

          console.error(err);
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Missing trailing comma.
    Open

        program.commands[0]
    Severity: Minor
    Found in tenon-cli.js by eslint

    require or disallow trailing commas (comma-dangle)

    Trailing commas in object literals are valid according to the ECMAScript 5 (and ECMAScript 3!) spec. However, IE8 (when not in IE8 document mode) and below will throw an error when it encounters trailing commas in JavaScript.

    var foo = {
    bar: "baz",
    qux: "quux",
};

    Trailing commas simplify adding and removing items to objects and arrays, since only the lines you are modifying must be touched. Another argument in favor of trailing commas is that it improves the clarity of diffs when an item is added or removed from an object or array:

    Less clear:

    var foo = {
-    bar: "baz",
-    qux: "quux"
+    bar: "baz"
 };

    More clear:

    var foo = {
     bar: "baz",
-    qux: "quux",
 };

    Rule Details

    This rule enforces consistent use of trailing commas in object and array literals.

    Options

    This rule has a string option or an object option:

    {
    "comma-dangle": ["error", "never"],
    // or
    "comma-dangle": ["error", {
        "arrays": "never",
        "objects": "never",
        "imports": "never",
        "exports": "never",
        "functions": "ignore",
    }]
}
    • "never" (default) disallows trailing commas
    • "always" requires trailing commas
    • "always-multiline" requires trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }
    • "only-multiline" allows (but does not require) trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }

    Trailing commas in function declarations and function calls are valid syntax since ECMAScript 2017; however, the string option does not check these situations for backwards compatibility.

    You can also use an object option to configure this rule for each type of syntax. Each of the following options can be set to "never", "always", "always-multiline", "only-multiline", or "ignore". The default for each option is "never" unless otherwise specified.

    • arrays is for array literals and array patterns of destructuring. (e.g. let [a,] = [1,];)
    • objects is for object literals and object patterns of destructuring. (e.g. let {a,} = {a: 1};)
    • imports is for import declarations of ES Modules. (e.g. import {a,} from "foo";)
    • exports is for export declarations of ES Modules. (e.g. export {a,};)
    • functions is for function declarations and function calls. (e.g. (function(a,){ })(b,);)
      functions is set to "ignore" by default for consistency with the string option.

    never

    Examples of incorrect code for this rule with the default "never" option:

    /*eslint comma-dangle: ["error", "never"]*/

var foo = {
    bar: "baz",
    qux: "quux",
};

var arr = [1,2,];

foo({
  bar: "baz",
  qux: "quux",
});

    Examples of correct code for this rule with the default "never" option:

    /*eslint comma-dangle: ["error", "never"]*/

var foo = {
    bar: "baz",
    qux: "quux"
};

var arr = [1,2];

foo({
  bar: "baz",
  qux: "quux"
});

    always

    Examples of incorrect code for this rule with the "always" option:

    /*eslint comma-dangle: ["error", "always"]*/

var foo = {
    bar: "baz",
    qux: "quux"
};

var arr = [1,2];

foo({
  bar: "baz",
  qux: "quux"
});

    Examples of correct code for this rule with the "always" option:

    /*eslint comma-dangle: ["error", "always"]*/

var foo = {
    bar: "baz",
    qux: "quux",
};

var arr = [1,2,];

foo({
  bar: "baz",
  qux: "quux",
});

    always-multiline

    Examples of incorrect code for this rule with the "always-multiline" option:

    /*eslint comma-dangle: ["error", "always-multiline"]*/

var foo = {
    bar: "baz",
    qux: "quux"
};

var foo = { bar: "baz", qux: "quux", };

var arr = [1,2,];

var arr = [1,
    2,];

var arr = [
    1,
    2
];

foo({
  bar: "baz",
  qux: "quux"
});

    Examples of correct code for this rule with the "always-multiline" option:

    /*eslint comma-dangle: ["error", "always-multiline"]*/

var foo = {
    bar: "baz",
    qux: "quux",
};

var foo = {bar: "baz", qux: "quux"};
var arr = [1,2];

var arr = [1,
    2];

var arr = [
    1,
    2,
];

foo({
  bar: "baz",
  qux: "quux",
});

    only-multiline

    Examples of incorrect code for this rule with the "only-multiline" option:

    /*eslint comma-dangle: ["error", "only-multiline"]*/

var foo = { bar: "baz", qux: "quux", };

var arr = [1,2,];

var arr = [1,
    2,];

    Examples of correct code for this rule with the "only-multiline" option:

    /*eslint comma-dangle: ["error", "only-multiline"]*/

var foo = {
    bar: "baz",
    qux: "quux",
};

var foo = {
    bar: "baz",
    qux: "quux"
};

var foo = {bar: "baz", qux: "quux"};
var arr = [1,2];

var arr = [1,
    2];

var arr = [
    1,
    2,
];

var arr = [
    1,
    2
];

foo({
  bar: "baz",
  qux: "quux",
});

foo({
  bar: "baz",
  qux: "quux"
});

    functions

    Examples of incorrect code for this rule with the {"functions": "never"} option:

    /*eslint comma-dangle: ["error", {"functions": "never"}]*/

function foo(a, b,) {
}

foo(a, b,);
new foo(a, b,);

    Examples of correct code for this rule with the {"functions": "never"} option:

    /*eslint comma-dangle: ["error", {"functions": "never"}]*/

function foo(a, b) {
}

foo(a, b);
new foo(a, b);

    Examples of incorrect code for this rule with the {"functions": "always"} option:

    /*eslint comma-dangle: ["error", {"functions": "always"}]*/

function foo(a, b) {
}

foo(a, b);
new foo(a, b);

    Examples of correct code for this rule with the {"functions": "always"} option:

    /*eslint comma-dangle: ["error", {"functions": "always"}]*/

function foo(a, b,) {
}

foo(a, b,);
new foo(a, b,);

    When Not To Use It

    You can turn this rule off if you are not concerned with dangling commas. Source: http://eslint.org/docs/rules/

    Unexpected console statement.
    Open

          console.error('Failed to write file...');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

                  console.error('Failed to parse Tenon response into CSV format');
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

                  console.error(err);
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Unexpected console statement.
    Open

          console.error(e.message);
    Severity: Minor
    Found in tenon-cli.js by eslint

    disallow the use of console (no-console)

    In JavaScript that is designed to be executed in the browser, it's considered a best practice to avoid using methods on console. Such messages are considered to be for debugging purposes and therefore not suitable to ship to the client. In general, calls using console should be stripped before being pushed to production.

    console.log("Made it here.");
console.error("That shouldn't have happened.");

    Rule Details

    This rule disallows calls to methods of the console object.

    Examples of incorrect code for this rule:

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

console.log("Log a debug level message.");
console.warn("Log a warn level message.");
console.error("Log an error level message.");

    Examples of correct code for this rule:

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

// custom console
Console.log("Hello world!");

    Options

    This rule has an object option for exceptions:

    • "allow" has an array of strings which are allowed methods of the console object

    Examples of additional correct code for this rule with a sample { "allow": ["warn", "error"] } option:

    /*eslint no-console: ["error", { allow: ["warn", "error"] }] */

console.warn("Log a warn level message.");
console.error("Log an error level message.");

    When Not To Use It

    If you're using Node.js, however, console is used to output information to the user and so is not strictly used for debugging purposes. If you are developing for Node.js then you most likely do not want this rule enabled.

    Related Rules

    Expected parentheses around arrow function argument having a body with curly braces.
    Open

    getStdin().then(pipedHTML => {
    Severity: Minor
    Found in tenon-cli.js by eslint

    Require parens in arrow function arguments (arrow-parens)

    Arrow functions can omit parentheses when they have exactly one parameter. In all other cases the parameter(s) must be wrapped in parentheses. This rule enforces the consistent use of parentheses in arrow functions.

    Rule Details

    This rule enforces parentheses around arrow function parameters regardless of arity. For example:

    /*eslint-env es6*/

// Bad
a => {}

// Good
(a) => {}

    Following this style will help you find arrow functions (=>) which may be mistakenly included in a condition when a comparison such as >= was the intent.

    /*eslint-env es6*/

// Bad
if (a => 2) {
}

// Good
if (a >= 2) {
}

    The rule can also be configured to discourage the use of parens when they are not required:

    /*eslint-env es6*/

// Bad
(a) => {}

// Good
a => {}

    Options

    This rule has a string option and an object one.

    String options are:

    • "always" (default) requires parens around arguments in all cases.
    • "as-needed" allows omitting parens when there is only one argument.

    Object properties for variants of the "as-needed" option:

    • "requireForBlockBody": true modifies the as-needed rule in order to require parens if the function body is in an instructions block (surrounded by braces).

    always

    Examples of incorrect code for this rule with the default "always" option:

    /*eslint arrow-parens: ["error", "always"]*/
/*eslint-env es6*/

a => {};
a => a;
a => {'\n'};
a.then(foo => {});
a.then(foo => a);
a(foo => { if (true) {} });

    Examples of correct code for this rule with the default "always" option:

    /*eslint arrow-parens: ["error", "always"]*/
/*eslint-env es6*/

() => {};
(a) => {};
(a) => a;
(a) => {'\n'}
a.then((foo) => {});
a.then((foo) => { if (true) {} });

    If Statements

    One of benefits of this option is that it prevents the incorrect use of arrow functions in conditionals:

    /*eslint-env es6*/

var a = 1;
var b = 2;
// ...
if (a => b) {
 console.log('bigger');
} else {
 console.log('smaller');
}
// outputs 'bigger', not smaller as expected

    The contents of the if statement is an arrow function, not a comparison.

    If the arrow function is intentional, it should be wrapped in parens to remove ambiguity.

    /*eslint-env es6*/

var a = 1;
var b = 0;
// ...
if ((a) => b) {
 console.log('truthy value returned');
} else {
 console.log('falsey value returned');
}
// outputs 'truthy value returned'

    The following is another example of this behavior:

    /*eslint-env es6*/

var a = 1, b = 2, c = 3, d = 4;
var f = a => b ? c: d;
// f = ?

    f is an arrow function which takes a as an argument and returns the result of b ? c: d.

    This should be rewritten like so:

    /*eslint-env es6*/

var a = 1, b = 2, c = 3, d = 4;
var f = (a) => b ? c: d;

    as-needed

    Examples of incorrect code for this rule with the "as-needed" option:

    /*eslint arrow-parens: ["error", "as-needed"]*/
/*eslint-env es6*/

(a) => {};
(a) => a;
(a) => {'\n'};
a.then((foo) => {});
a.then((foo) => a);
a((foo) => { if (true) {} });

    Examples of correct code for this rule with the "as-needed" option:

    /*eslint arrow-parens: ["error", "as-needed"]*/
/*eslint-env es6*/

() => {};
a => {};
a => a;
a => {'\n'};
a.then(foo => {});
a.then(foo => { if (true) {} });
(a, b, c) => a;
(a = 10) => a;
([a, b]) => a;
({a, b}) => a;

    requireForBlockBody

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

    /*eslint arrow-parens: [2, "as-needed", { "requireForBlockBody": true }]*/
/*eslint-env es6*/

(a) => a;
a => {};
a => {'\n'};
a.map((x) => x * x);
a.map(x => {
  return x * x;
});
a.then(foo => {});

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

    /*eslint arrow-parens: [2, "as-needed", { "requireForBlockBody": true }]*/
/*eslint-env es6*/

(a) => {};
(a) => {'\n'};
a => ({});
() => {};
a => a;
a.then((foo) => {});
a.then((foo) => { if (true) {} });
a((foo) => { if (true) {} });
(a, b, c) => a;
(a = 10) => a;
([a, b]) => a;
({a, b}) => a;

    Further Reading

    Unexpected string concatenation.
    Open

          console.log('\'' + field + '\' is required');
    Severity: Minor
    Found in tenon-cli.js by eslint

    Suggest using template literals instead of string concatenation. (prefer-template)

    In ES2015 (ES6), we can use template literals instead of string concatenation.

    var str = "Hello, " + name + "!";
    /*eslint-env es6*/

var str = `Hello, ${name}!`;

    Rule Details

    This rule is aimed to flag usage of + operators with strings.

    Examples

    Examples of incorrect code for this rule:

    /*eslint prefer-template: "error"*/

var str = "Hello, " + name + "!";
var str = "Time: " + (12 * 60 * 60 * 1000);

    Examples of correct code for this rule:

    /*eslint prefer-template: "error"*/
/*eslint-env es6*/

var str = "Hello World!";
var str = `Hello, ${name}!`;
var str = `Time: ${12 * 60 * 60 * 1000}`;

// This is reported by `no-useless-concat`.
var str = "Hello, " + "World!";

    When Not To Use It

    This rule should not be used in ES3/5 environments.

    In ES2015 (ES6) or later, if you don't want to be notified about string concatenation, you can safely disable this rule.

    Related Rules

    Unexpected string concatenation.
    Open

          console.error('Failed to read input file, ' + allOptions.in);
    Severity: Minor
    Found in tenon-cli.js by eslint

    Suggest using template literals instead of string concatenation. (prefer-template)

    In ES2015 (ES6), we can use template literals instead of string concatenation.

    var str = "Hello, " + name + "!";
    /*eslint-env es6*/

var str = `Hello, ${name}!`;

    Rule Details

    This rule is aimed to flag usage of + operators with strings.

    Examples

    Examples of incorrect code for this rule:

    /*eslint prefer-template: "error"*/

var str = "Hello, " + name + "!";
var str = "Time: " + (12 * 60 * 60 * 1000);

    Examples of correct code for this rule:

    /*eslint prefer-template: "error"*/
/*eslint-env es6*/

var str = "Hello World!";
var str = `Hello, ${name}!`;
var str = `Time: ${12 * 60 * 60 * 1000}`;

// This is reported by `no-useless-concat`.
var str = "Hello, " + "World!";

    When Not To Use It

    This rule should not be used in ES3/5 environments.

    In ES2015 (ES6) or later, if you don't want to be notified about string concatenation, you can safely disable this rule.

    Related Rules

    A constructor name should not start with a lowercase letter.
    Open

      const tenonApi = new tenonNode({
    Severity: Minor
    Found in tenon-cli.js by eslint

    require constructor names to begin with a capital letter (new-cap)

    The new operator in JavaScript creates a new instance of a particular type of object. That type of object is represented by a constructor function. Since constructor functions are just regular functions, the only defining characteristic is that new is being used as part of the call. Native JavaScript functions begin with an uppercase letter to distinguish those functions that are to be used as constructors from functions that are not. Many style guides recommend following this pattern to more easily determine which functions are to be used as constructors.

    var friend = new Person();

    Rule Details

    This rule requires constructor names to begin with a capital letter. Certain built-in identifiers are exempt from this rule. These identifiers are:

    • Array
    • Boolean
    • Date
    • Error
    • Function
    • Number
    • Object
    • RegExp
    • String
    • Symbol

    Examples of correct code for this rule:

    /*eslint new-cap: "error"*/

function foo(arg) {
    return Boolean(arg);
}

    Options

    This rule has an object option:

    • "newIsCap": true (default) requires all new operators to be called with uppercase-started functions.
    • "newIsCap": false allows new operators to be called with lowercase-started or uppercase-started functions.
    • "capIsNew": true (default) requires all uppercase-started functions to be called with new operators.
    • "capIsNew": false allows uppercase-started functions to be called without new operators.
    • "newIsCapExceptions" allows specified lowercase-started function names to be called with the new operator.
    • "newIsCapExceptionPattern" allows any lowercase-started function names that match the specified regex pattern to be called with the new operator.
    • "capIsNewExceptions" allows specified uppercase-started function names to be called without the new operator.
    • "capIsNewExceptionPattern" allows any uppercase-started function names that match the specified regex pattern to be called without the new operator.
    • "properties": true (default) enables checks on object properties
    • "properties": false disables checks on object properties

    newIsCap

    Examples of incorrect code for this rule with the default { "newIsCap": true } option:

    /*eslint new-cap: ["error", { "newIsCap": true }]*/

var friend = new person();

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

    /*eslint new-cap: ["error", { "newIsCap": true }]*/

var friend = new Person();

    Examples of correct code for this rule with the { "newIsCap": false } option:

    /*eslint new-cap: ["error", { "newIsCap": false }]*/

var friend = new person();

    capIsNew

    Examples of incorrect code for this rule with the default { "capIsNew": true } option:

    /*eslint new-cap: ["error", { "capIsNew": true }]*/

var colleague = Person();

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

    /*eslint new-cap: ["error", { "capIsNew": true }]*/

var colleague = new Person();

    Examples of correct code for this rule with the { "capIsNew": false } option:

    /*eslint new-cap: ["error", { "capIsNew": false }]*/

var colleague = Person();

    newIsCapExceptions

    Examples of additional correct code for this rule with the { "newIsCapExceptions": ["events"] } option:

    /*eslint new-cap: ["error", { "newIsCapExceptions": ["events"] }]*/

var events = require('events');

var emitter = new events();

    newIsCapExceptionPattern

    Examples of additional correct code for this rule with the { "newIsCapExceptionPattern": "^person\.." } option:

    /*eslint new-cap: ["error", { "newIsCapExceptionPattern": "^person\.." }]*/

var friend = new person.acquaintance();
var bestFriend = new person.friend();

    capIsNewExceptions

    Examples of additional correct code for this rule with the { "capIsNewExceptions": ["Person"] } option:

    /*eslint new-cap: ["error", { "capIsNewExceptions": ["Person"] }]*/

function foo(arg) {
    return Person(arg);
}

    capIsNewExceptionPattern

    Examples of additional correct code for this rule with the { "capIsNewExceptionPattern": "^Person\.." } option:

    /*eslint new-cap: ["error", { "capIsNewExceptionPattern": "^Person\.." }]*/

var friend = person.Acquaintance();
var bestFriend = person.Friend();

    properties

    Examples of incorrect code for this rule with the default { "properties": true } option:

    /*eslint new-cap: ["error", { "properties": true }]*/

var friend = new person.acquaintance();

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

    /*eslint new-cap: ["error", { "properties": true }]*/

var friend = new person.Acquaintance();

    Examples of correct code for this rule with the { "properties": false } option:

    /*eslint new-cap: ["error", { "properties": false }]*/

var friend = new person.acquaintance();

    When Not To Use It

    If you have conventions that don't require an uppercase letter for constructors, or don't require capitalized functions be only used as constructors, turn this rule off. Source: http://eslint.org/docs/rules/

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

          parseFormat(result).then((formattedResult) => {
        if (allOptions.out) {
          console.log('Writing results to file...');
          try {
            writeResultFile(formattedResult, allOptions.out);
    Severity: Major
    Found in tenon-cli.js and 1 other location - About 4 hrs to fix
    bin/tenon-cli.js on lines 218..232

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

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

          case 'html':
        return new Promise((resolve) => {
          reporters.HTML(json, (err, result) => {
            if (err) {
              console.error('Failed to parse Tenon response into HTML format');
    Severity: Major
    Found in tenon-cli.js and 2 other locations - About 2 hrs to fix
    tenon-cli.js on lines 149..160
    tenon-cli.js on lines 173..184

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

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

          case 'csv':
        return new Promise((resolve) => {
          reporters.CSV(json, (err, result) => {
            if (err) {
              console.error('Failed to parse Tenon response into CSV format');
    Severity: Major
    Found in tenon-cli.js and 2 other locations - About 2 hrs to fix
    tenon-cli.js on lines 161..172
    tenon-cli.js on lines 173..184

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

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

          case 'xunit':
        return new Promise((resolve) => {
          reporters.XUnit(json, (err, result) => {
            if (err) {
              console.error('Failed to parse Tenon response into XUnit format');
    Severity: Major
    Found in tenon-cli.js and 2 other locations - About 2 hrs to fix
    tenon-cli.js on lines 149..160
    tenon-cli.js on lines 161..172

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

    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

      Object.keys(tenonOptions).forEach((key) => {
    const value = tenonOptions[key];
    if (allOptions[key]) {
      if (key === 'store' || key === 'fragment') {
        allOptions[key] = +allOptions[key];
    Severity: Major
    Found in tenon-cli.js and 1 other location - About 2 hrs to fix
    bin/tenon-cli.js on lines 90..98

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

    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

      const tenonOptions = {
    waitFor: 'waitFor',
    level: 'level',
    certainty: 'certainty',
    importance: 'importance',
    Severity: Major
    Found in tenon-cli.js and 1 other location - About 1 hr to fix
    bin/tenon-cli.js on lines 73..86

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

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

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

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

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

    Refactorings

    Further Reading

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

          if (result.status >= 400) {
        console.error('Tenon reported an error:');
        console.error(JSON.stringify(result, null, '\t'));
        process.exit(1);
      }
    Severity: Major
    Found in tenon-cli.js and 1 other location - About 1 hr to fix
    bin/tenon-cli.js on lines 211..215

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

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

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

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

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

    Refactorings

    Further Reading

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

      if (program.commands[0].args.length > 1) {
    console.error('You have supplied too many arguments, for help type \'tenon --help\'');
    process.exit(1);
  }
    Severity: Minor
    Found in tenon-cli.js and 1 other location - About 55 mins to fix
    bin/tenon-cli.js on lines 30..33

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

    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

      requiredFields.forEach((field) => {
    if (!allOptions[field]) {
      console.log('\'' + field + '\' is required');
      process.exit(1);
    }
    Severity: Minor
    Found in tenon-cli.js and 1 other location - About 35 mins to fix
    bin/tenon-cli.js on lines 109..114

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

    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

        try {
      configuration = fs.readFileSync(program.commands[0].config, 'utf8');
      configuration = JSON.parse(configuration);
    } catch (e) {
      // The json could not be parsed or read
    Severity: Minor
    Found in tenon-cli.js and 1 other location - About 35 mins to fix
    bin/tenon-cli.js on lines 41..49

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

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

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

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

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

    Refactorings

    Further Reading

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

      if (process.env.TENON_API_KEY && !allOptions.key) {
    allOptions.key = process.env.TENON_API_KEY;
  }
    Severity: Minor
    Found in tenon-cli.js and 1 other location - About 35 mins to fix
    bin/tenon-cli.js on lines 68..70

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

    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

    Import and Export Declarations are not supported yet on Node v4.
    Open

    import getStdin from 'get-stdin';
    Severity: Minor
    Found in tenon-cli.js by eslint

    For more information visit Source: http://eslint.org/docs/rules/

    This file needs no shebang.
    Open

    import fs from 'fs';
    Severity: Minor
    Found in tenon-cli.js by eslint

    For more information visit Source: http://eslint.org/docs/rules/

    Import and Export Declarations are not supported yet on Node v4.
    Open

    import { parseCommand } from './';
    Severity: Minor
    Found in tenon-cli.js by eslint

    For more information visit Source: http://eslint.org/docs/rules/

    Import and Export Declarations are not supported yet on Node v4.
    Open

    import fs from 'fs';
    Severity: Minor
    Found in tenon-cli.js by eslint

    For more information visit Source: http://eslint.org/docs/rules/

    Import and Export Declarations are not supported yet on Node v4.
    Open

    import tenonNode from 'tenon-node';
    Severity: Minor
    Found in tenon-cli.js by eslint

    For more information visit Source: http://eslint.org/docs/rules/

    Import and Export Declarations are not supported yet on Node v4.
    Open

    import reporters from 'tenon-reporters';
    Severity: Minor
    Found in tenon-cli.js by eslint

    For more information visit Source: http://eslint.org/docs/rules/

    There are no issues that match your filters.

    Category
    Status