From ac85f461599f1fc972ef4481765cacb5ca4f0f6d Mon Sep 17 00:00:00 2001 From: "Nicholas C. Zakas" Date: Fri, 16 Nov 2018 10:06:06 -0800 Subject: [PATCH 1/6] Chore: Extract config comment parsing --- lib/linter.js | 119 +- lib/util/config-comment-parser.js | 140 ++ tests/lib/util/config-comment-parser.js | 1908 +++++++++++++++++++++++ 3 files changed, 2055 insertions(+), 112 deletions(-) create mode 100644 lib/util/config-comment-parser.js create mode 100644 tests/lib/util/config-comment-parser.js diff --git a/lib/linter.js b/lib/linter.js index edcf741069c..84a53784a5c 100644 --- a/lib/linter.js +++ b/lib/linter.js @@ -11,7 +11,6 @@ const eslintScope = require("eslint-scope"), evk = require("eslint-visitor-keys"), - levn = require("levn"), lodash = require("lodash"), CodePathAnalyzer = require("./code-path-analysis/code-path-analyzer"), ConfigOps = require("./config/config-ops"), @@ -25,6 +24,7 @@ const eslintScope = require("eslint-scope"), createReportTranslator = require("./report-translator"), Rules = require("./rules"), timing = require("./util/timing"), + ConfigCommentParser = require("./util/config-comment-parser"), astUtils = require("./util/ast-utils"), pkg = require("../package.json"), SourceCodeFixer = require("./util/source-code-fixer"); @@ -32,6 +32,7 @@ const eslintScope = require("eslint-scope"), const debug = require("debug")("eslint:linter"); const MAX_AUTOFIX_PASSES = 10; const DEFAULT_PARSER_NAME = "espree"; +const commentParser = new ConfigCommentParser(); //------------------------------------------------------------------------------ // Typedefs @@ -59,112 +60,6 @@ const DEFAULT_PARSER_NAME = "espree"; // Helpers //------------------------------------------------------------------------------ -/** - * Parses a list of "name:boolean_value" or/and "name" options divided by comma or - * whitespace. - * @param {string} string The string to parse. - * @param {Comment} comment The comment node which has the string. - * @returns {Object} Result map object of names and boolean values - */ -function parseBooleanConfig(string, comment) { - const items = {}; - - // Collapse whitespace around `:` and `,` to make parsing easier - const trimmedString = string.replace(/\s*([:,])\s*/g, "$1"); - - trimmedString.split(/\s|,+/).forEach(name => { - if (!name) { - return; - } - - // value defaults to "false" (if not provided), e.g: "foo" => ["foo", "false"] - const [key, value = "false"] = name.split(":"); - - items[key] = { - value: value === "true", - comment - }; - }); - return items; -} - -/** - * Parses a JSON-like config. - * @param {string} string The string to parse. - * @param {Object} location Start line and column of comments for potential error message. - * @returns {({success: true, config: Object}|{success: false, error: Problem})} Result map object - */ -function parseJsonConfig(string, location) { - let items = {}; - - // Parses a JSON-like comment by the same way as parsing CLI option. - try { - items = levn.parse("Object", string) || {}; - - // Some tests say that it should ignore invalid comments such as `/*eslint no-alert:abc*/`. - // Also, commaless notations have invalid severity: - // "no-alert: 2 no-console: 2" --> {"no-alert": "2 no-console: 2"} - // Should ignore that case as well. - if (ConfigOps.isEverySeverityValid(items)) { - return { - success: true, - config: items - }; - } - } catch (ex) { - - // ignore to parse the string by a fallback. - } - - /* - * Optionator cannot parse commaless notations. - * But we are supporting that. So this is a fallback for that. - */ - items = {}; - const normalizedString = string.replace(/([a-zA-Z0-9\-/]+):/g, "\"$1\":").replace(/(]|[0-9])\s+(?=")/, "$1,"); - - try { - items = JSON.parse(`{${normalizedString}}`); - } catch (ex) { - return { - success: false, - error: { - ruleId: null, - fatal: true, - severity: 2, - message: `Failed to parse JSON from '${normalizedString}': ${ex.message}`, - line: location.start.line, - column: location.start.column + 1 - } - }; - - } - - return { - success: true, - config: items - }; -} - -/** - * Parses a config of values separated by comma. - * @param {string} string The string to parse. - * @returns {Object} Result map of values and true values - */ -function parseListConfig(string) { - const items = {}; - - // Collapse whitespace around , - string.replace(/\s*,\s*/g, ",").split(/,+/).forEach(name => { - const trimmedName = name.trim(); - - if (trimmedName) { - items[trimmedName] = true; - } - }); - return items; -} - /** * Ensures that variables representing built-in properties of the Global Object, * and any globals declared by special block comments, are present in the global @@ -243,7 +138,7 @@ function addDeclaredGlobals(globalScope, configGlobals, commentDirectives) { * @returns {DisableDirective[]} Directives from the comment */ function createDisableDirectives(type, loc, value) { - const ruleIds = Object.keys(parseListConfig(value)); + const ruleIds = Object.keys(commentParser.parseListConfig(value)); const directiveRules = ruleIds.length ? ruleIds : [null]; return directiveRules.map(ruleId => ({ type, line: loc.line, column: loc.column + 1, ruleId })); @@ -296,12 +191,12 @@ function getDirectiveComments(filename, ast, ruleMapper) { } else if (comment.type === "Block") { switch (match[1]) { case "exported": - Object.assign(exportedVariables, parseBooleanConfig(directiveValue, comment)); + Object.assign(exportedVariables, commentParser.parseBooleanConfig(directiveValue, comment)); break; case "globals": case "global": - Object.assign(enabledGlobals, parseBooleanConfig(directiveValue, comment)); + Object.assign(enabledGlobals, commentParser.parseBooleanConfig(directiveValue, comment)); break; case "eslint-disable": @@ -313,7 +208,7 @@ function getDirectiveComments(filename, ast, ruleMapper) { break; case "eslint": { - const parseResult = parseJsonConfig(directiveValue, comment.loc); + const parseResult = commentParser.parseJsonConfig(directiveValue, comment.loc); if (parseResult.success) { Object.keys(parseResult.config).forEach(name => { @@ -393,7 +288,7 @@ function findEslintEnv(text) { eslintEnvPattern.lastIndex = 0; while ((match = eslintEnvPattern.exec(text))) { - retv = Object.assign(retv || {}, parseListConfig(match[1])); + retv = Object.assign(retv || {}, commentParser.parseListConfig(match[1])); } return retv; diff --git a/lib/util/config-comment-parser.js b/lib/util/config-comment-parser.js new file mode 100644 index 00000000000..dee8e55da52 --- /dev/null +++ b/lib/util/config-comment-parser.js @@ -0,0 +1,140 @@ +/** + * @fileoverview Config Comment Parser + * @author Nicholas C. Zakas + */ + +/* eslint-disable class-methods-use-this*/ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const levn = require("levn"), + ConfigOps = require("../config/config-ops"); + +const debug = require("debug")("eslint:config-comment-parser"); + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * Object to parse ESLint configuration comments inside JavaScript files. + * @name ConfigCommentParser + */ +module.exports = class ConfigCommentParser { + + constructor() { + debug("Created ConfigCommentParser"); + + // empty for now + } + + /** + * Parses a list of "name:boolean_value" or/and "name" options divided by comma or + * whitespace. Used for "global" and "exported" comments. + * @param {string} string The string to parse. + * @param {Comment} comment The comment node which has the string. + * @returns {Object} Result map object of names and boolean values + */ + parseBooleanConfig(string, comment) { + const items = {}; + + // Collapse whitespace around `:` and `,` to make parsing easier + const trimmedString = string.replace(/\s*([:,])\s*/g, "$1"); + + trimmedString.split(/\s|,+/).forEach(name => { + if (!name) { + return; + } + + // value defaults to "false" (if not provided), e.g: "foo" => ["foo", "false"] + const [key, value = "false"] = name.split(":"); + + items[key] = { + value: value === "true", + comment + }; + }); + return items; + } + + /** + * Parses a JSON-like config. + * @param {string} string The string to parse. + * @param {Object} location Start line and column of comments for potential error message. + * @returns {({success: true, config: Object}|{success: false, error: Problem})} Result map object + */ + parseJsonConfig(string, location) { + let items = {}; + + // Parses a JSON-like comment by the same way as parsing CLI option. + try { + items = levn.parse("Object", string) || {}; + + // Some tests say that it should ignore invalid comments such as `/*eslint no-alert:abc*/`. + // Also, commaless notations have invalid severity: + // "no-alert: 2 no-console: 2" --> {"no-alert": "2 no-console: 2"} + // Should ignore that case as well. + if (ConfigOps.isEverySeverityValid(items)) { + return { + success: true, + config: items + }; + } + } catch (ex) { + + // ignore to parse the string by a fallback. + } + + /* + * Optionator cannot parse commaless notations. + * But we are supporting that. So this is a fallback for that. + */ + items = {}; + const normalizedString = string.replace(/([a-zA-Z0-9\-/]+):/g, "\"$1\":").replace(/(]|[0-9])\s+(?=")/, "$1,"); + + try { + items = JSON.parse(`{${normalizedString}}`); + } catch (ex) { + return { + success: false, + error: { + ruleId: null, + fatal: true, + severity: 2, + message: `Failed to parse JSON from '${normalizedString}': ${ex.message}`, + line: location.start.line, + column: location.start.column + 1 + } + }; + + } + + return { + success: true, + config: items + }; + } + + /** + * Parses a config of values separated by comma. + * @param {string} string The string to parse. + * @returns {Object} Result map of values and true values + */ + parseListConfig(string) { + const items = {}; + + // Collapse whitespace around commas + string.replace(/\s*,\s*/g, ",").split(/,+/).forEach(name => { + const trimmedName = name.trim(); + + if (trimmedName) { + items[trimmedName] = true; + } + }); + return items; + } + +}; diff --git a/tests/lib/util/config-comment-parser.js b/tests/lib/util/config-comment-parser.js new file mode 100644 index 00000000000..52cd337ad34 --- /dev/null +++ b/tests/lib/util/config-comment-parser.js @@ -0,0 +1,1908 @@ +/** + * @fileoverview Tests for ConfigCommentParser object. + * @author Nicholas C. Zakas + */ +/* globals window */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const assert = require("chai").assert, + ConfigCommentParser = require("../../../lib/util/config-comment-parser"); + +//------------------------------------------------------------------------------ +// Constants +//------------------------------------------------------------------------------ + + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +// Tests +//------------------------------------------------------------------------------ + +describe("ConfigCommentParser", () => { + + let commentParser; + const location = { + start: { + line: 1, + column: 0 + } + }; + + beforeEach(() => { + commentParser = new ConfigCommentParser(); + }); + + describe("parseJsonConfig", () => { + + it("should parse JSON config with one item", () => { + const code = "no-alert:0"; + const result = commentParser.parseJsonConfig(code, location); + + + assert.deepStrictEqual(result, { + success: true, + config: { + "no-alert": 0 + } + }); + }); + + it("should parse JSON config with two items", () => { + const code = "no-alert:0 semi: 2"; + const result = commentParser.parseJsonConfig(code, location); + + + assert.deepStrictEqual(result, { + success: true, + config: { + "no-alert": 0, + semi: 2 + } + }); + }); + + it("should parse JSON config with two comma-separated items", () => { + const code = "no-alert:0,semi: 2"; + const result = commentParser.parseJsonConfig(code, location); + + + assert.deepStrictEqual(result, { + success: true, + config: { + "no-alert": 0, + semi: 2 + } + }); + }); + + it("should parse JSON config with two items and a string severity", () => { + const code = "no-alert:off,semi: 2"; + const result = commentParser.parseJsonConfig(code, location); + + + assert.deepStrictEqual(result, { + success: true, + config: { + "no-alert": "off", + semi: 2 + } + }); + }); + + it("should parse JSON config with two items and options", () => { + const code = "no-alert:off, semi: [2, always]"; + const result = commentParser.parseJsonConfig(code, location); + + + assert.deepStrictEqual(result, { + success: true, + config: { + "no-alert": "off", + semi: [2, "always"] + } + }); + }); + + it("should parse JSON config with two items and options from plugins", () => { + const code = "plugin/no-alert:off, plugin/semi: [2, always]"; + const result = commentParser.parseJsonConfig(code, location); + + assert.deepStrictEqual(result, { + success: true, + config: { + "plugin/no-alert": "off", + "plugin/semi": [2, "always"] + } + }); + }); + + + }); + + describe("parseBooleanConfig", () => { + + const comment = {}; + + it("should parse Boolean config with one item", () => { + const code = "a: true"; + const result = commentParser.parseBooleanConfig(code, comment); + + assert.deepStrictEqual(result, { + a: { + value: true, + comment + } + }); + }); + + it("should parse Boolean config with one item and no value", () => { + const code = "a"; + const result = commentParser.parseBooleanConfig(code, comment); + + assert.deepStrictEqual(result, { + a: { + value: false, + comment + } + }); + }); + + it("should parse Boolean config with two items", () => { + const code = "a: true b:false"; + const result = commentParser.parseBooleanConfig(code, comment); + + assert.deepStrictEqual(result, { + a: { + value: true, + comment + }, + b: { + value: false, + comment + } + }); + }); + + it("should parse Boolean config with two comma-separated items", () => { + const code = "a: true, b:false"; + const result = commentParser.parseBooleanConfig(code, comment); + + assert.deepStrictEqual(result, { + a: { + value: true, + comment + }, + b: { + value: false, + comment + } + }); + }); + + it("should parse Boolean config with two comma-separated items and no values", () => { + const code = "a , b"; + const result = commentParser.parseBooleanConfig(code, comment); + + assert.deepStrictEqual(result, { + a: { + value: false, + comment + }, + b: { + value: false, + comment + } + }); + }); + }); + + describe("parseListConfig", () => { + + it("should parse list config with one item", () => { + const code = "a"; + const result = commentParser.parseListConfig(code); + + assert.deepStrictEqual(result, { + a: true + }); + }); + + it("should parse list config with two items", () => { + const code = "a, b"; + const result = commentParser.parseListConfig(code); + + assert.deepStrictEqual(result, { + a: true, + b: true + }); + }); + + it("should parse list config with two items and exta whitespace", () => { + const code = " a , b "; + const result = commentParser.parseListConfig(code); + + assert.deepStrictEqual(result, { + a: true, + b: true + }); + }); + }); + + // it("should report a violation when the report is right before the comment", () => { + // const code = " /* eslint-disable */ "; + + /* + * linter.defineRule("checker", context => ({ + * Program() { + * context.report({ loc: { line: 1, column: 0 }, message: "foo" }); + * } + * })); + * const problems = linter.verify(code, { rules: { checker: "error" } }); + */ + + /* + * assert.strictEqual(problems.length, 1); + * assert.strictEqual(problems[0].message, "foo"); + * }); + */ + + // it("should not report a violation when the report is right at the start of the comment", () => { + // const code = " /* eslint-disable */ "; + + /* + * linter.defineRule("checker", context => ({ + * Program() { + * context.report({ loc: { line: 1, column: 1 }, message: "foo" }); + * } + * })); + * const problems = linter.verify(code, { rules: { checker: "error" } }); + */ + + /* + * assert.strictEqual(problems.length, 0); + * }); + */ + + // it("rules should not change initial config", () => { + // const config = { rules: { "test-plugin/test-rule": 2 } }; + // const codeA = "/*eslint test-plugin/test-rule: 0*/ var a = \"trigger violation\";"; + // const codeB = "var a = \"trigger violation\";"; + // let messages = linter.verify(codeA, config, filename, false); + + // assert.strictEqual(messages.length, 0); + + /* + * messages = linter.verify(codeB, config, filename, false); + * assert.strictEqual(messages.length, 1); + * }); + * }); + */ + + /* + * describe("when evaluating code with comments to enable and disable all reporting", () => { + * it("should report a violation", () => { + */ + + // const code = [ + // "/*eslint-disable */", + // "alert('test');", + // "/*eslint-enable */", + // "alert('test');" + // ].join("\n"); + // const config = { rules: { "no-alert": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * assert.strictEqual(messages[0].message, "Unexpected alert."); + * assert.include(messages[0].nodeType, "CallExpression"); + * assert.strictEqual(messages[0].line, 4); + * }); + */ + + // it("should not report a violation", () => { + // const code = [ + // "/*eslint-disable */", + // "alert('test');", + // "alert('test');" + // ].join("\n"); + // const config = { rules: { "no-alert": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + // it("should not report a violation", () => { + // const code = [ + // " alert('test1');/*eslint-disable */\n", + // "alert('test');", + // " alert('test');\n", + // "/*eslint-enable */alert('test2');" + // ].join(""); + // const config = { rules: { "no-alert": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 2); + * assert.strictEqual(messages[0].column, 21); + * assert.strictEqual(messages[1].column, 19); + * }); + */ + + // it("should report a violation", () => { + + // const code = [ + // "/*eslint-disable */", + // "alert('test');", + // "/*eslint-disable */", + // "alert('test');", + // "/*eslint-enable*/", + // "alert('test');", + // "/*eslint-enable*/" + // ].join("\n"); + + // const config = { rules: { "no-alert": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 1); + * }); + */ + + + // it("should not report a violation", () => { + // const code = [ + // "/*eslint-disable */", + // "(function(){ var b = 44;})()", + // "/*eslint-enable */;any();" + // ].join("\n"); + + // const config = { rules: { "no-unused-vars": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + // it("should not report a violation", () => { + // const code = [ + // "(function(){ /*eslint-disable */ var b = 44;})()", + // "/*eslint-enable */;any();" + // ].join("\n"); + + // const config = { rules: { "no-unused-vars": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + * }); + */ + + // describe("when evaluating code with comments to ignore reporting on specific rules on a specific line", () => { + + /* + * describe("eslint-disable-line", () => { + * it("should report a violation", () => { + * const code = [ + * "alert('test'); // eslint-disable-line no-alert", + * "console.log('test');" // here + * ].join("\n"); + * const config = { + * rules: { + * "no-alert": 1, + * "no-console": 1 + * } + * }; + */ + + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 1); + + /* + * assert.strictEqual(messages[0].ruleId, "no-console"); + * }); + */ + + /* + * it("should report a violation", () => { + * const code = [ + * "alert('test'); // eslint-disable-line no-alert", + * "console.log('test'); // eslint-disable-line no-console", + * "alert('test');" // here + * ].join("\n"); + * const config = { + * rules: { + * "no-alert": 1, + * "no-console": 1 + * } + * }; + */ + + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 1); + + /* + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * }); + */ + + // it("should report a violation if eslint-disable-line in a block comment is not on a single line", () => { + // const code = [ + // "/* eslint-disable-line", + // "*", + // "*/ console.log('test');" // here + // ].join("\n"); + // const config = { + // rules: { + // "no-console": 1 + // } + // }; + + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 2); + + /* + * assert.strictEqual(messages[1].ruleId, "no-console"); + * }); + */ + + // it("should not disable rule and add an extra report if eslint-disable-line in a block comment is not on a single line", () => { + // const code = [ + // "alert('test'); /* eslint-disable-line ", + // "no-alert */" + // ].join("\n"); + // const config = { + // rules: { + // "no-alert": 1 + // } + // }; + + // const messages = linter.verify(code, config); + + /* + * assert.deepStrictEqual(messages, [ + * { + * ruleId: "no-alert", + * severity: 1, + * line: 1, + * column: 1, + * endLine: 1, + * endColumn: 14, + * message: "Unexpected alert.", + * messageId: "unexpected", + * nodeType: "CallExpression" + * }, + * { + * ruleId: null, + * severity: 2, + * message: "eslint-disable-line comment should not span multiple lines.", + * line: 1, + * column: 16, + * endLine: 2, + * endColumn: 12, + * nodeType: null + * } + * ]); + * }); + */ + + // it("should not report a violation for eslint-disable-line in block comment", () => { + // const code = [ + // "alert('test'); // eslint-disable-line no-alert", + // "alert('test'); /*eslint-disable-line no-alert*/" + // ].join("\n"); + // const config = { + // rules: { + // "no-alert": 1 + // } + // }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + /* + * it("should not report a violation", () => { + * const code = [ + * "alert('test'); // eslint-disable-line no-alert", + * "console.log('test'); // eslint-disable-line no-console" + * ].join("\n"); + * const config = { + * rules: { + * "no-alert": 1, + * "no-console": 1 + * } + * }; + */ + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + /* + * it("should not report a violation", () => { + * const code = [ + * "alert('test') // eslint-disable-line no-alert, quotes, semi", + * "console.log('test'); // eslint-disable-line" + * ].join("\n"); + * const config = { + * rules: { + * "no-alert": 1, + * quotes: [1, "double"], + * semi: [1, "always"], + * "no-console": 1 + * } + * }; + */ + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + // it("should not report a violation", () => { + // const code = [ + // "alert('test') /* eslint-disable-line no-alert, quotes, semi */", + // "console.log('test'); /* eslint-disable-line */" + // ].join("\n"); + // const config = { + // rules: { + // "no-alert": 1, + // quotes: [1, "double"], + // semi: [1, "always"], + // "no-console": 1 + // } + // }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + // it("should ignore violations of multiple rules when specified in mixed comments", () => { + // const code = [ + // " alert(\"test\"); /* eslint-disable-line no-alert */ // eslint-disable-line quotes" + // ].join("\n"); + // const config = { + // rules: { + // "no-alert": 1, + // quotes: [1, "single"] + // } + // }; + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + * }); + */ + + /* + * describe("eslint-disable-next-line", () => { + * it("should ignore violation of specified rule on next line", () => { + * const code = [ + * "// eslint-disable-next-line no-alert", + * "alert('test');", + * "console.log('test');" + * ].join("\n"); + * const config = { + * rules: { + * "no-alert": 1, + * "no-console": 1 + * } + * }; + * const messages = linter.verify(code, config, filename); + */ + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].ruleId, "no-console"); + * }); + */ + + // it("should ignore violation of specified rule if eslint-disable-next-line is a block comment", () => { + // const code = [ + // "/* eslint-disable-next-line no-alert */", + // "alert('test');", + // "console.log('test');" + // ].join("\n"); + // const config = { + // rules: { + // "no-alert": 1, + // "no-console": 1 + // } + // }; + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 1); + // assert.strictEqual(messages[0].ruleId, "no-console"); + // }); + // it("should ignore violation of specified rule if eslint-disable-next-line is a block comment", () => { + // const code = [ + // "/* eslint-disable-next-line no-alert */", + // "alert('test');" + // ].join("\n"); + // const config = { + // rules: { + // "no-alert": 1 + // } + // }; + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + // it("should not ignore violation if block comment is not on a single line", () => { + // const code = [ + // "/* eslint-disable-next-line", + // "no-alert */alert('test');" + // ].join("\n"); + // const config = { + // rules: { + // "no-alert": 1 + // } + // }; + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 2); + * assert.strictEqual(messages[1].ruleId, "no-alert"); + * }); + */ + + /* + * it("should ignore violations only of specified rule", () => { + * const code = [ + * "// eslint-disable-next-line no-console", + * "alert('test');", + * "console.log('test');" + * ].join("\n"); + * const config = { + * rules: { + * "no-alert": 1, + * "no-console": 1 + * } + * }; + * const messages = linter.verify(code, config, filename); + */ + + /* + * assert.strictEqual(messages.length, 2); + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * assert.strictEqual(messages[1].ruleId, "no-console"); + * }); + */ + + /* + * it("should ignore violations of multiple rules when specified", () => { + * const code = [ + * "// eslint-disable-next-line no-alert, quotes", + * "alert(\"test\");", + * "console.log('test');" + * ].join("\n"); + * const config = { + * rules: { + * "no-alert": 1, + * quotes: [1, "single"], + * "no-console": 1 + * } + * }; + * const messages = linter.verify(code, config, filename); + */ + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].ruleId, "no-console"); + * }); + */ + + // it("should ignore violations of multiple rules when specified in mixed comments", () => { + // const code = [ + // "/* eslint-disable-next-line no-alert */ // eslint-disable-next-line quotes", + // "alert(\"test\");" + // ].join("\n"); + // const config = { + // rules: { + // "no-alert": 1, + // quotes: [1, "single"] + // } + // }; + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + /* + * it("should ignore violations of only the specified rule on next line", () => { + * const code = [ + * "// eslint-disable-next-line quotes", + * "alert(\"test\");", + * "console.log('test');" + * ].join("\n"); + * const config = { + * rules: { + * "no-alert": 1, + * quotes: [1, "single"], + * "no-console": 1 + * } + * }; + * const messages = linter.verify(code, config, filename); + */ + + /* + * assert.strictEqual(messages.length, 2); + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * assert.strictEqual(messages[1].ruleId, "no-console"); + * }); + */ + + /* + * it("should ignore violations of specified rule on next line only", () => { + * const code = [ + * "alert('test');", + * "// eslint-disable-next-line no-alert", + * "alert('test');", + * "console.log('test');" + * ].join("\n"); + * const config = { + * rules: { + * "no-alert": 1, + * "no-console": 1 + * } + * }; + * const messages = linter.verify(code, config, filename); + */ + + /* + * assert.strictEqual(messages.length, 2); + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * assert.strictEqual(messages[1].ruleId, "no-console"); + * }); + */ + + /* + * it("should ignore all rule violations on next line if none specified", () => { + * const code = [ + * "// eslint-disable-next-line", + * "alert(\"test\");", + * "console.log('test')" + * ].join("\n"); + * const config = { + * rules: { + * semi: [1, "never"], + * quotes: [1, "single"], + * "no-alert": 1, + * "no-console": 1 + * } + * }; + * const messages = linter.verify(code, config, filename); + */ + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].ruleId, "no-console"); + * }); + */ + + // it("should ignore violations if eslint-disable-next-line is a block comment", () => { + // const code = [ + // "alert('test');", + // "/* eslint-disable-next-line no-alert */", + // "alert('test');", + // "console.log('test');" + // ].join("\n"); + // const config = { + // rules: { + // "no-alert": 1, + // "no-console": 1 + // } + // }; + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 2); + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * assert.strictEqual(messages[1].ruleId, "no-console"); + * }); + */ + + // it("should report a violation", () => { + // const code = [ + // "/* eslint-disable-next-line", + // "*", + // "*/", + // "console.log('test');" // here + // ].join("\n"); + // const config = { + // rules: { + // "no-alert": 1, + // "no-console": 1 + // } + // }; + + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 2); + + /* + * assert.strictEqual(messages[1].ruleId, "no-console"); + * }); + */ + + /* + * it("should not ignore violations if comment is of the type Shebang", () => { + * const code = [ + * "#! eslint-disable-next-line no-alert", + * "alert('test');", + * "console.log('test');" + * ].join("\n"); + * const config = { + * rules: { + * "no-alert": 1, + * "no-console": 1 + * } + * }; + * const messages = linter.verify(code, config, filename); + */ + + /* + * assert.strictEqual(messages.length, 2); + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * assert.strictEqual(messages[1].ruleId, "no-console"); + * }); + * }); + * }); + */ + + // describe("when evaluating code with comments to enable and disable reporting of specific rules", () => { + + // it("should report a violation", () => { + // const code = [ + // "/*eslint-disable no-alert */", + // "alert('test');", + // "console.log('test');" // here + // ].join("\n"); + // const config = { rules: { "no-alert": 1, "no-console": 1 } }; + + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 1); + + /* + * assert.strictEqual(messages[0].ruleId, "no-console"); + * }); + */ + + // it("should report no violation", () => { + // const code = [ + // "/*eslint-disable no-unused-vars */", + // "var foo; // eslint-disable-line no-unused-vars", + // "var bar;", + // "/* eslint-enable no-unused-vars */" // here + // ].join("\n"); + // const config = { rules: { "no-unused-vars": 2 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + /* + * it("should report no violation", () => { + * const code = [ + * "var foo1; // eslint-disable-line no-unused-vars", + * "var foo2; // eslint-disable-line no-unused-vars", + * "var foo3; // eslint-disable-line no-unused-vars", + * "var foo4; // eslint-disable-line no-unused-vars", + * "var foo5; // eslint-disable-line no-unused-vars" + * ].join("\n"); + * const config = { rules: { "no-unused-vars": 2 } }; + */ + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + // it("should report no violation", () => { + // const code = [ + // "/* eslint-disable quotes */", + // "console.log(\"foo\");", + // "/* eslint-enable quotes */" + // ].join("\n"); + // const config = { rules: { quotes: 2 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + // it("should report a violation", () => { + // const code = [ + // "/*eslint-disable no-alert, no-console */", + // "alert('test');", + // "console.log('test');", + // "/*eslint-enable*/", + + /* + * "alert('test');", // here + * "console.log('test');" // here + * ].join("\n"); + * const config = { rules: { "no-alert": 1, "no-console": 1 } }; + */ + + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 2); + + /* + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * assert.strictEqual(messages[0].line, 5); + * assert.strictEqual(messages[1].ruleId, "no-console"); + * assert.strictEqual(messages[1].line, 6); + * }); + */ + + // it("should report a violation", () => { + // const code = [ + // "/*eslint-disable no-alert */", + // "alert('test');", + // "console.log('test');", + // "/*eslint-enable no-console */", + + /* + * "alert('test');" // here + * ].join("\n"); + * const config = { rules: { "no-alert": 1, "no-console": 1 } }; + */ + + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 1); + + /* + * assert.strictEqual(messages[0].ruleId, "no-console"); + * }); + */ + + + // it("should report a violation", () => { + // const code = [ + // "/*eslint-disable no-alert, no-console */", + // "alert('test');", + // "console.log('test');", + // "/*eslint-enable no-alert*/", + + /* + * "alert('test');", // here + * "console.log('test');" + * ].join("\n"); + * const config = { rules: { "no-alert": 1, "no-console": 1 } }; + */ + + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 1); + + /* + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * assert.strictEqual(messages[0].line, 5); + * }); + */ + + + // it("should report a violation", () => { + // const code = [ + // "/*eslint-disable no-alert */", + + // "/*eslint-disable no-console */", + // "alert('test');", + // "console.log('test');", + // "/*eslint-enable */", + + /* + * "alert('test');", // here + * "console.log('test');", // here + */ + + // "/*eslint-enable */", + + /* + * "alert('test');", // here + * "console.log('test');", // here + */ + + // "/*eslint-enable*/" + // ].join("\n"); + // const config = { rules: { "no-alert": 1, "no-console": 1 } }; + + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 4); + + /* + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * assert.strictEqual(messages[0].line, 6); + */ + + /* + * assert.strictEqual(messages[1].ruleId, "no-console"); + * assert.strictEqual(messages[1].line, 7); + */ + + /* + * assert.strictEqual(messages[2].ruleId, "no-alert"); + * assert.strictEqual(messages[2].line, 9); + */ + + /* + * assert.strictEqual(messages[3].ruleId, "no-console"); + * assert.strictEqual(messages[3].line, 10); + */ + + // }); + + // it("should report a violation", () => { + // const code = [ + // "/*eslint-disable no-alert, no-console */", + // "alert('test');", + // "console.log('test');", + + // "/*eslint-enable no-alert */", + + /* + * "alert('test');", // here + * "console.log('test');", + */ + + // "/*eslint-enable no-console */", + + // "alert('test');", // here + // "console.log('test');", // here + // "/*eslint-enable no-console */" + // ].join("\n"); + // const config = { rules: { "no-alert": 1, "no-console": 1 } }; + + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 3); + + /* + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * assert.strictEqual(messages[0].line, 5); + */ + + /* + * assert.strictEqual(messages[1].ruleId, "no-alert"); + * assert.strictEqual(messages[1].line, 8); + */ + + /* + * assert.strictEqual(messages[2].ruleId, "no-console"); + * assert.strictEqual(messages[2].line, 9); + */ + + // }); + + // it("should report a violation when severity is warn", () => { + // const code = [ + // "/*eslint-disable no-alert, no-console */", + // "alert('test');", + // "console.log('test');", + + // "/*eslint-enable no-alert */", + + /* + * "alert('test');", // here + * "console.log('test');", + */ + + // "/*eslint-enable no-console */", + + // "alert('test');", // here + // "console.log('test');", // here + // "/*eslint-enable no-console */" + // ].join("\n"); + // const config = { rules: { "no-alert": "warn", "no-console": "warn" } }; + + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 3); + + /* + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * assert.strictEqual(messages[0].line, 5); + */ + + /* + * assert.strictEqual(messages[1].ruleId, "no-alert"); + * assert.strictEqual(messages[1].line, 8); + */ + + /* + * assert.strictEqual(messages[2].ruleId, "no-console"); + * assert.strictEqual(messages[2].line, 9); + */ + + /* + * }); + * }); + */ + + // describe("when evaluating code with comments to enable and disable multiple comma separated rules", () => { + // const code = "/*eslint no-alert:1, no-console:0*/ alert('test'); console.log('test');"; + + /* + * it("should report a violation", () => { + * const config = { rules: { "no-console": 1, "no-alert": 0 } }; + */ + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * assert.strictEqual(messages[0].message, "Unexpected alert."); + * assert.include(messages[0].nodeType, "CallExpression"); + * }); + * }); + */ + + // describe("when evaluating code with comments to enable configurable rule", () => { + // const code = "/*eslint quotes:[2, \"double\"]*/ alert('test');"; + + /* + * it("should report a violation", () => { + * const config = { rules: { quotes: [2, "single"] } }; + */ + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].ruleId, "quotes"); + * assert.strictEqual(messages[0].message, "Strings must use doublequote."); + * assert.include(messages[0].nodeType, "Literal"); + * }); + * }); + */ + + // describe("when evaluating code with comments to enable configurable rule using string severity", () => { + // const code = "/*eslint quotes:[\"error\", \"double\"]*/ alert('test');"; + + /* + * it("should report a violation", () => { + * const config = { rules: { quotes: [2, "single"] } }; + */ + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].ruleId, "quotes"); + * assert.strictEqual(messages[0].message, "Strings must use doublequote."); + * assert.include(messages[0].nodeType, "Literal"); + * }); + * }); + */ + + // describe("when evaluating code with incorrectly formatted comments to disable rule", () => { + // it("should report a violation", () => { + // const code = "/*eslint no-alert:'1'*/ alert('test');"; + + // const config = { rules: { "no-alert": 1 } }; + + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 2); + + // /* + // * Incorrectly formatted comment threw error; + // * message from caught exception + // * may differ amongst UAs, so verifying + // * first part only as defined in the + // * parseJsonConfig function in lib/eslint.js + // */ + // assert.match(messages[0].message, /^Failed to parse JSON from ' "no-alert":'1'':/); + // assert.strictEqual(messages[0].line, 1); + // assert.strictEqual(messages[0].column, 1); + + /* + * assert.strictEqual(messages[1].ruleId, "no-alert"); + * assert.strictEqual(messages[1].message, "Unexpected alert."); + * assert.include(messages[1].nodeType, "CallExpression"); + * }); + */ + + // it("should report a violation", () => { + // const code = "/*eslint no-alert:abc*/ alert('test');"; + + // const config = { rules: { "no-alert": 1 } }; + + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 2); + + // /* + // * Incorrectly formatted comment threw error; + // * message from caught exception + // * may differ amongst UAs, so verifying + // * first part only as defined in the + // * parseJsonConfig function in lib/eslint.js + // */ + // assert.match(messages[0].message, /^Failed to parse JSON from ' "no-alert":abc':/); + // assert.strictEqual(messages[0].line, 1); + // assert.strictEqual(messages[0].column, 1); + + /* + * assert.strictEqual(messages[1].ruleId, "no-alert"); + * assert.strictEqual(messages[1].message, "Unexpected alert."); + * assert.include(messages[1].nodeType, "CallExpression"); + * }); + */ + + // it("should report a violation", () => { + // const code = "/*eslint no-alert:0 2*/ alert('test');"; + + // const config = { rules: { "no-alert": 1 } }; + + // const messages = linter.verify(code, config, filename); + + // assert.strictEqual(messages.length, 2); + + // /* + // * Incorrectly formatted comment threw error; + // * message from caught exception + // * may differ amongst UAs, so verifying + // * first part only as defined in the + // * parseJsonConfig function in lib/eslint.js + // */ + // assert.match(messages[0].message, /^Failed to parse JSON from ' "no-alert":0 2':/); + // assert.strictEqual(messages[0].line, 1); + // assert.strictEqual(messages[0].column, 1); + + /* + * assert.strictEqual(messages[1].ruleId, "no-alert"); + * assert.strictEqual(messages[1].message, "Unexpected alert."); + * assert.include(messages[1].nodeType, "CallExpression"); + * }); + * }); + */ + + // describe("when evaluating code with comments which have colon in its value", () => { + // const code = "/* eslint max-len: [2, 100, 2, {ignoreUrls: true, ignorePattern: \"data:image\\/|\\s*require\\s*\\(|^\\s*loader\\.lazy|-\\*-\"}] */\nalert('test');"; + + /* + * it("should not parse errors, should report a violation", () => { + * const messages = linter.verify(code, {}, filename); + */ + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].ruleId, "max-len"); + * assert.strictEqual(messages[0].message, "Line 1 exceeds the maximum line length of 100."); + * assert.include(messages[0].nodeType, "Program"); + * }); + * }); + */ + + /* + * describe("when evaluating a file with a shebang", () => { + * const code = "#!bin/program\n\nvar foo;;"; + */ + + /* + * it("should preserve line numbers", () => { + * const config = { rules: { "no-extra-semi": 1 } }; + * const messages = linter.verify(code, config); + */ + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].ruleId, "no-extra-semi"); + * assert.strictEqual(messages[0].nodeType, "EmptyStatement"); + * assert.strictEqual(messages[0].line, 3); + * }); + */ + + /* + * it("should have a comment with the shebang in it", () => { + * const config = { rules: { checker: "error" } }; + * const spy = sandbox.spy(context => { + * const comments = context.getAllComments(); + */ + + /* + * assert.strictEqual(comments.length, 1); + * assert.strictEqual(comments[0].type, "Shebang"); + * return {}; + * }); + */ + + /* + * linter.defineRule("checker", spy); + * linter.verify(code, config); + * assert(spy.calledOnce); + * }); + * }); + */ + + /* + * describe("when evaluating broken code", () => { + * const code = BROKEN_TEST_CODE; + */ + + /* + * it("should report a violation with a useful parse error prefix", () => { + * const messages = linter.verify(code); + */ + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].severity, 2); + * assert.isNull(messages[0].ruleId); + * assert.strictEqual(messages[0].line, 1); + * assert.strictEqual(messages[0].column, 4); + * assert.isTrue(messages[0].fatal); + * assert.match(messages[0].message, /^Parsing error:/); + * }); + */ + + /* + * it("should report source code where the issue is present", () => { + * const inValidCode = [ + * "var x = 20;", + * "if (x ==4 {", + * " x++;", + * "}" + * ]; + * const messages = linter.verify(inValidCode.join("\n")); + */ + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].severity, 2); + * assert.isTrue(messages[0].fatal); + * assert.match(messages[0].message, /^Parsing error:/); + * }); + * }); + */ + + /* + * describe("when using an invalid (undefined) rule", () => { + * linter = new Linter(); + */ + + /* + * const code = TEST_CODE; + * const results = linter.verify(code, { rules: { foobar: 2 } }); + * const result = results[0]; + * const warningResult = linter.verify(code, { rules: { foobar: 1 } })[0]; + * const arrayOptionResults = linter.verify(code, { rules: { foobar: [2, "always"] } }); + * const objectOptionResults = linter.verify(code, { rules: { foobar: [1, { bar: false }] } }); + * const resultsMultiple = linter.verify(code, { rules: { foobar: 2, barfoo: 1 } }); + */ + + /* + * it("should add a stub rule", () => { + * assert.isNotNull(result); + * assert.isArray(results); + * assert.isObject(result); + * assert.property(result, "ruleId"); + * assert.strictEqual(result.ruleId, "foobar"); + * }); + */ + + /* + * it("should report that the rule does not exist", () => { + * assert.property(result, "message"); + * assert.strictEqual(result.message, "Definition for rule 'foobar' was not found"); + * }); + */ + + /* + * it("should report at the correct severity", () => { + * assert.property(result, "severity"); + * assert.strictEqual(result.severity, 2); + * assert.strictEqual(warningResult.severity, 1); + * }); + */ + + /* + * it("should accept any valid rule configuration", () => { + * assert.isObject(arrayOptionResults[0]); + * assert.isObject(objectOptionResults[0]); + * }); + */ + + /* + * it("should report multiple missing rules", () => { + * assert.isArray(resultsMultiple); + */ + + /* + * assert.deepStrictEqual( + * resultsMultiple[1], + * { + * ruleId: "barfoo", + * message: "Definition for rule 'barfoo' was not found", + * line: 1, + * column: 1, + * severity: 1, + * nodeType: null + * } + * ); + * }); + * }); + */ + + /* + * describe("when using a rule which has been replaced", () => { + * const code = TEST_CODE; + * const results = linter.verify(code, { rules: { "no-comma-dangle": 2 } }); + */ + + /* + * it("should report the new rule", () => { + * assert.strictEqual(results[0].ruleId, "no-comma-dangle"); + * assert.strictEqual(results[0].message, "Rule 'no-comma-dangle' was removed and replaced by: comma-dangle"); + * }); + * }); + */ + + /* + * describe("when calling getRules", () => { + * it("should return all loaded rules", () => { + * const rules = linter.getRules(); + */ + + /* + * assert.isAbove(rules.size, 230); + * assert.isObject(rules.get("no-alert")); + * }); + * }); + */ + + /* + * describe("when calling version", () => { + * it("should return current version number", () => { + * const version = linter.version; + */ + + /* + * assert.isString(version); + * assert.isTrue(parseInt(version[0], 10) >= 3); + * }); + * }); + */ + + /* + * describe("when evaluating an empty string", () => { + * it("runs rules", () => { + * linter.defineRule("no-programs", context => ({ + * Program(node) { + * context.report({ node, message: "No programs allowed." }); + * } + * })); + */ + + /* + * assert.strictEqual( + * linter.verify("", { rules: { "no-programs": "error" } }).length, + * 1 + * ); + * }); + * }); + */ + + /* + * describe("when evaluating code without comments to environment", () => { + * it("should report a violation when using typed array", () => { + * const code = "var array = new Uint8Array();"; + */ + + // const config = { rules: { "no-undef": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 1); + * }); + */ + + /* + * it("should report a violation when using Promise", () => { + * const code = "new Promise();"; + */ + + // const config = { rules: { "no-undef": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 1); + * }); + * }); + */ + + // describe("when evaluating code with comments to environment", () => { + // it("should not support legacy config", () => { + // const code = "/*jshint mocha:true */ describe();"; + + // const config = { rules: { "no-undef": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].ruleId, "no-undef"); + * assert.strictEqual(messages[0].nodeType, "Identifier"); + * assert.strictEqual(messages[0].line, 1); + * }); + */ + + // it("should not report a violation", () => { + // const code = "/*eslint-env es6 */ new Promise();"; + + // const config = { rules: { "no-undef": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + // it("should not report a violation", () => { + // const code = "/*eslint-env mocha,node */ require();describe();"; + + // const config = { rules: { "no-undef": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + // it("should not report a violation", () => { + // const code = "/*eslint-env mocha */ suite();test();"; + + // const config = { rules: { "no-undef": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + // it("should not report a violation", () => { + // const code = "/*eslint-env amd */ define();require();"; + + // const config = { rules: { "no-undef": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + // it("should not report a violation", () => { + // const code = "/*eslint-env jasmine */ expect();spyOn();"; + + // const config = { rules: { "no-undef": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + // it("should not report a violation", () => { + // const code = "/*globals require: true */ /*eslint-env node */ require = 1;"; + + // const config = { rules: { "no-undef": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + // it("should not report a violation", () => { + // const code = "/*eslint-env node */ process.exit();"; + + // const config = { rules: {} }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + // it("should not report a violation", () => { + // const code = "/*eslint no-process-exit: 0 */ /*eslint-env node */ process.exit();"; + + // const config = { rules: { "no-undef": 1 } }; + + // const messages = linter.verify(code, config, filename); + + /* + * assert.strictEqual(messages.length, 0); + * }); + * }); + */ + + /* + * describe("when evaluating code with comments to change config when allowInlineConfig is enabled", () => { + * it("should report a violation for disabling rules", () => { + * const code = [ + * "alert('test'); // eslint-disable-line no-alert" + * ].join("\n"); + * const config = { + * rules: { + * "no-alert": 1 + * } + * }; + */ + + /* + * const messages = linter.verify(code, config, { + * filename, + * allowInlineConfig: false + * }); + */ + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * }); + */ + + // it("should report a violation for global variable declarations", () => { + // const code = [ + // "/* global foo */" + // ].join("\n"); + // const config = { + // rules: { + // test: 2 + // } + // }; + // let ok = false; + + /* + * linter.defineRules({ + * test(context) { + * return { + * Program() { + * const scope = context.getScope(); + * const sourceCode = context.getSourceCode(); + * const comments = sourceCode.getAllComments(); + */ + + // assert.strictEqual(1, comments.length); + + // const foo = getVariable(scope, "foo"); + + // assert.notOk(foo); + + /* + * ok = true; + * } + * }; + * } + * }); + */ + + /* + * linter.verify(code, config, { allowInlineConfig: false }); + * assert(ok); + * }); + */ + + // it("should report a violation for eslint-disable", () => { + // const code = [ + // "/* eslint-disable */", + // "alert('test');" + // ].join("\n"); + // const config = { + // rules: { + // "no-alert": 1 + // } + // }; + + /* + * const messages = linter.verify(code, config, { + * filename, + * allowInlineConfig: false + * }); + */ + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * }); + */ + + // it("should not report a violation for rule changes", () => { + // const code = [ + // "/*eslint no-alert:2*/", + // "alert('test');" + // ].join("\n"); + // const config = { + // rules: { + // "no-alert": 0 + // } + // }; + + /* + * const messages = linter.verify(code, config, { + * filename, + * allowInlineConfig: false + * }); + */ + + /* + * assert.strictEqual(messages.length, 0); + * }); + */ + + /* + * it("should report a violation for disable-line", () => { + * const code = [ + * "alert('test'); // eslint-disable-line" + * ].join("\n"); + * const config = { + * rules: { + * "no-alert": 2 + * } + * }; + */ + + /* + * const messages = linter.verify(code, config, { + * filename, + * allowInlineConfig: false + * }); + */ + + /* + * assert.strictEqual(messages.length, 1); + * assert.strictEqual(messages[0].ruleId, "no-alert"); + * }); + */ + + // it("should report a violation for env changes", () => { + // const code = [ + // "/*eslint-env browser*/" + // ].join("\n"); + // const config = { + // rules: { + // test: 2 + // } + // }; + // let ok = false; + + /* + * linter.defineRules({ + * test(context) { + * return { + * Program() { + * const scope = context.getScope(); + * const sourceCode = context.getSourceCode(); + * const comments = sourceCode.getAllComments(); + */ + + // assert.strictEqual(1, comments.length); + + // const windowVar = getVariable(scope, "window"); + + // assert.notOk(windowVar.eslintExplicitGlobal); + + /* + * ok = true; + * } + * }; + * } + * }); + */ + + /* + * linter.verify(code, config, { allowInlineConfig: false }); + * assert(ok); + * }); + * }); + */ + + // describe("reportUnusedDisable option", () => { + // it("reports problems for unused eslint-disable comments", () => { + // assert.deepStrictEqual( + // linter.verify("/* eslint-disable */", {}, { reportUnusedDisableDirectives: true }), + // [ + // { + // ruleId: null, + // message: "Unused eslint-disable directive (no problems were reported).", + // line: 1, + // column: 1, + // severity: 2, + // nodeType: null + // } + // ] + // ); + // }); + // }); + + /* + * describe("when evaluating code with comments to change config when allowInlineConfig is disabled", () => { + * it("should not report a violation", () => { + * const code = [ + * "alert('test'); // eslint-disable-line no-alert" + * ].join("\n"); + * const config = { + * rules: { + * "no-alert": 1 + * } + * }; + */ + + /* + * const messages = linter.verify(code, config, { + * filename, + * allowInlineConfig: true + * }); + */ + + /* + * assert.strictEqual(messages.length, 0); + * }); + * }); + */ + +}); From 188e1f879490b73c4d25b85a74a8dba141a19b48 Mon Sep 17 00:00:00 2001 From: "Nicholas C. Zakas" Date: Fri, 16 Nov 2018 13:29:11 -0800 Subject: [PATCH 2/6] Add more debug messages --- lib/util/config-comment-parser.js | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/lib/util/config-comment-parser.js b/lib/util/config-comment-parser.js index dee8e55da52..37118e13aff 100644 --- a/lib/util/config-comment-parser.js +++ b/lib/util/config-comment-parser.js @@ -39,6 +39,8 @@ module.exports = class ConfigCommentParser { * @returns {Object} Result map object of names and boolean values */ parseBooleanConfig(string, comment) { + debug("Parsing Boolean config"); + const items = {}; // Collapse whitespace around `:` and `,` to make parsing easier @@ -67,6 +69,8 @@ module.exports = class ConfigCommentParser { * @returns {({success: true, config: Object}|{success: false, error: Problem})} Result map object */ parseJsonConfig(string, location) { + debug("Parsing JSON config"); + let items = {}; // Parses a JSON-like comment by the same way as parsing CLI option. @@ -85,6 +89,7 @@ module.exports = class ConfigCommentParser { } } catch (ex) { + debug("Levn parsing failed; falling back to manual parsing."); // ignore to parse the string by a fallback. } @@ -98,6 +103,8 @@ module.exports = class ConfigCommentParser { try { items = JSON.parse(`{${normalizedString}}`); } catch (ex) { + debug("Manual parsing failed."); + return { success: false, error: { @@ -124,6 +131,8 @@ module.exports = class ConfigCommentParser { * @returns {Object} Result map of values and true values */ parseListConfig(string) { + debug("Parsing list config"); + const items = {}; // Collapse whitespace around commas From e8b77e3f9d44f7c059b55696b37419da21b7cd9e Mon Sep 17 00:00:00 2001 From: "Nicholas C. Zakas" Date: Fri, 16 Nov 2018 13:33:36 -0800 Subject: [PATCH 3/6] Fix linting errors --- lib/util/config-comment-parser.js | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/util/config-comment-parser.js b/lib/util/config-comment-parser.js index 37118e13aff..e01ef78ba17 100644 --- a/lib/util/config-comment-parser.js +++ b/lib/util/config-comment-parser.js @@ -90,6 +90,7 @@ module.exports = class ConfigCommentParser { } catch (ex) { debug("Levn parsing failed; falling back to manual parsing."); + // ignore to parse the string by a fallback. } @@ -132,7 +133,7 @@ module.exports = class ConfigCommentParser { */ parseListConfig(string) { debug("Parsing list config"); - + const items = {}; // Collapse whitespace around commas From 2d9f8be76b2a9384909f2f6cb30a81dac89ae910 Mon Sep 17 00:00:00 2001 From: "Nicholas C. Zakas" Date: Mon, 19 Nov 2018 09:47:10 -0800 Subject: [PATCH 4/6] Remove unused tests and constructor --- lib/util/config-comment-parser.js | 6 - tests/lib/util/config-comment-parser.js | 1679 ----------------------- 2 files changed, 1685 deletions(-) diff --git a/lib/util/config-comment-parser.js b/lib/util/config-comment-parser.js index e01ef78ba17..88504caf1ca 100644 --- a/lib/util/config-comment-parser.js +++ b/lib/util/config-comment-parser.js @@ -25,12 +25,6 @@ const debug = require("debug")("eslint:config-comment-parser"); */ module.exports = class ConfigCommentParser { - constructor() { - debug("Created ConfigCommentParser"); - - // empty for now - } - /** * Parses a list of "name:boolean_value" or/and "name" options divided by comma or * whitespace. Used for "global" and "exported" comments. diff --git a/tests/lib/util/config-comment-parser.js b/tests/lib/util/config-comment-parser.js index 52cd337ad34..6dbe9381aff 100644 --- a/tests/lib/util/config-comment-parser.js +++ b/tests/lib/util/config-comment-parser.js @@ -2,7 +2,6 @@ * @fileoverview Tests for ConfigCommentParser object. * @author Nicholas C. Zakas */ -/* globals window */ "use strict"; @@ -13,15 +12,6 @@ const assert = require("chai").assert, ConfigCommentParser = require("../../../lib/util/config-comment-parser"); -//------------------------------------------------------------------------------ -// Constants -//------------------------------------------------------------------------------ - - -//------------------------------------------------------------------------------ -// Helpers -//------------------------------------------------------------------------------ - //------------------------------------------------------------------------------ // Tests //------------------------------------------------------------------------------ @@ -236,1673 +226,4 @@ describe("ConfigCommentParser", () => { }); }); - // it("should report a violation when the report is right before the comment", () => { - // const code = " /* eslint-disable */ "; - - /* - * linter.defineRule("checker", context => ({ - * Program() { - * context.report({ loc: { line: 1, column: 0 }, message: "foo" }); - * } - * })); - * const problems = linter.verify(code, { rules: { checker: "error" } }); - */ - - /* - * assert.strictEqual(problems.length, 1); - * assert.strictEqual(problems[0].message, "foo"); - * }); - */ - - // it("should not report a violation when the report is right at the start of the comment", () => { - // const code = " /* eslint-disable */ "; - - /* - * linter.defineRule("checker", context => ({ - * Program() { - * context.report({ loc: { line: 1, column: 1 }, message: "foo" }); - * } - * })); - * const problems = linter.verify(code, { rules: { checker: "error" } }); - */ - - /* - * assert.strictEqual(problems.length, 0); - * }); - */ - - // it("rules should not change initial config", () => { - // const config = { rules: { "test-plugin/test-rule": 2 } }; - // const codeA = "/*eslint test-plugin/test-rule: 0*/ var a = \"trigger violation\";"; - // const codeB = "var a = \"trigger violation\";"; - // let messages = linter.verify(codeA, config, filename, false); - - // assert.strictEqual(messages.length, 0); - - /* - * messages = linter.verify(codeB, config, filename, false); - * assert.strictEqual(messages.length, 1); - * }); - * }); - */ - - /* - * describe("when evaluating code with comments to enable and disable all reporting", () => { - * it("should report a violation", () => { - */ - - // const code = [ - // "/*eslint-disable */", - // "alert('test');", - // "/*eslint-enable */", - // "alert('test');" - // ].join("\n"); - // const config = { rules: { "no-alert": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * assert.strictEqual(messages[0].message, "Unexpected alert."); - * assert.include(messages[0].nodeType, "CallExpression"); - * assert.strictEqual(messages[0].line, 4); - * }); - */ - - // it("should not report a violation", () => { - // const code = [ - // "/*eslint-disable */", - // "alert('test');", - // "alert('test');" - // ].join("\n"); - // const config = { rules: { "no-alert": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - // it("should not report a violation", () => { - // const code = [ - // " alert('test1');/*eslint-disable */\n", - // "alert('test');", - // " alert('test');\n", - // "/*eslint-enable */alert('test2');" - // ].join(""); - // const config = { rules: { "no-alert": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 2); - * assert.strictEqual(messages[0].column, 21); - * assert.strictEqual(messages[1].column, 19); - * }); - */ - - // it("should report a violation", () => { - - // const code = [ - // "/*eslint-disable */", - // "alert('test');", - // "/*eslint-disable */", - // "alert('test');", - // "/*eslint-enable*/", - // "alert('test');", - // "/*eslint-enable*/" - // ].join("\n"); - - // const config = { rules: { "no-alert": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 1); - * }); - */ - - - // it("should not report a violation", () => { - // const code = [ - // "/*eslint-disable */", - // "(function(){ var b = 44;})()", - // "/*eslint-enable */;any();" - // ].join("\n"); - - // const config = { rules: { "no-unused-vars": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - // it("should not report a violation", () => { - // const code = [ - // "(function(){ /*eslint-disable */ var b = 44;})()", - // "/*eslint-enable */;any();" - // ].join("\n"); - - // const config = { rules: { "no-unused-vars": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - * }); - */ - - // describe("when evaluating code with comments to ignore reporting on specific rules on a specific line", () => { - - /* - * describe("eslint-disable-line", () => { - * it("should report a violation", () => { - * const code = [ - * "alert('test'); // eslint-disable-line no-alert", - * "console.log('test');" // here - * ].join("\n"); - * const config = { - * rules: { - * "no-alert": 1, - * "no-console": 1 - * } - * }; - */ - - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 1); - - /* - * assert.strictEqual(messages[0].ruleId, "no-console"); - * }); - */ - - /* - * it("should report a violation", () => { - * const code = [ - * "alert('test'); // eslint-disable-line no-alert", - * "console.log('test'); // eslint-disable-line no-console", - * "alert('test');" // here - * ].join("\n"); - * const config = { - * rules: { - * "no-alert": 1, - * "no-console": 1 - * } - * }; - */ - - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 1); - - /* - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * }); - */ - - // it("should report a violation if eslint-disable-line in a block comment is not on a single line", () => { - // const code = [ - // "/* eslint-disable-line", - // "*", - // "*/ console.log('test');" // here - // ].join("\n"); - // const config = { - // rules: { - // "no-console": 1 - // } - // }; - - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 2); - - /* - * assert.strictEqual(messages[1].ruleId, "no-console"); - * }); - */ - - // it("should not disable rule and add an extra report if eslint-disable-line in a block comment is not on a single line", () => { - // const code = [ - // "alert('test'); /* eslint-disable-line ", - // "no-alert */" - // ].join("\n"); - // const config = { - // rules: { - // "no-alert": 1 - // } - // }; - - // const messages = linter.verify(code, config); - - /* - * assert.deepStrictEqual(messages, [ - * { - * ruleId: "no-alert", - * severity: 1, - * line: 1, - * column: 1, - * endLine: 1, - * endColumn: 14, - * message: "Unexpected alert.", - * messageId: "unexpected", - * nodeType: "CallExpression" - * }, - * { - * ruleId: null, - * severity: 2, - * message: "eslint-disable-line comment should not span multiple lines.", - * line: 1, - * column: 16, - * endLine: 2, - * endColumn: 12, - * nodeType: null - * } - * ]); - * }); - */ - - // it("should not report a violation for eslint-disable-line in block comment", () => { - // const code = [ - // "alert('test'); // eslint-disable-line no-alert", - // "alert('test'); /*eslint-disable-line no-alert*/" - // ].join("\n"); - // const config = { - // rules: { - // "no-alert": 1 - // } - // }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - /* - * it("should not report a violation", () => { - * const code = [ - * "alert('test'); // eslint-disable-line no-alert", - * "console.log('test'); // eslint-disable-line no-console" - * ].join("\n"); - * const config = { - * rules: { - * "no-alert": 1, - * "no-console": 1 - * } - * }; - */ - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - /* - * it("should not report a violation", () => { - * const code = [ - * "alert('test') // eslint-disable-line no-alert, quotes, semi", - * "console.log('test'); // eslint-disable-line" - * ].join("\n"); - * const config = { - * rules: { - * "no-alert": 1, - * quotes: [1, "double"], - * semi: [1, "always"], - * "no-console": 1 - * } - * }; - */ - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - // it("should not report a violation", () => { - // const code = [ - // "alert('test') /* eslint-disable-line no-alert, quotes, semi */", - // "console.log('test'); /* eslint-disable-line */" - // ].join("\n"); - // const config = { - // rules: { - // "no-alert": 1, - // quotes: [1, "double"], - // semi: [1, "always"], - // "no-console": 1 - // } - // }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - // it("should ignore violations of multiple rules when specified in mixed comments", () => { - // const code = [ - // " alert(\"test\"); /* eslint-disable-line no-alert */ // eslint-disable-line quotes" - // ].join("\n"); - // const config = { - // rules: { - // "no-alert": 1, - // quotes: [1, "single"] - // } - // }; - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - * }); - */ - - /* - * describe("eslint-disable-next-line", () => { - * it("should ignore violation of specified rule on next line", () => { - * const code = [ - * "// eslint-disable-next-line no-alert", - * "alert('test');", - * "console.log('test');" - * ].join("\n"); - * const config = { - * rules: { - * "no-alert": 1, - * "no-console": 1 - * } - * }; - * const messages = linter.verify(code, config, filename); - */ - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].ruleId, "no-console"); - * }); - */ - - // it("should ignore violation of specified rule if eslint-disable-next-line is a block comment", () => { - // const code = [ - // "/* eslint-disable-next-line no-alert */", - // "alert('test');", - // "console.log('test');" - // ].join("\n"); - // const config = { - // rules: { - // "no-alert": 1, - // "no-console": 1 - // } - // }; - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 1); - // assert.strictEqual(messages[0].ruleId, "no-console"); - // }); - // it("should ignore violation of specified rule if eslint-disable-next-line is a block comment", () => { - // const code = [ - // "/* eslint-disable-next-line no-alert */", - // "alert('test');" - // ].join("\n"); - // const config = { - // rules: { - // "no-alert": 1 - // } - // }; - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - // it("should not ignore violation if block comment is not on a single line", () => { - // const code = [ - // "/* eslint-disable-next-line", - // "no-alert */alert('test');" - // ].join("\n"); - // const config = { - // rules: { - // "no-alert": 1 - // } - // }; - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 2); - * assert.strictEqual(messages[1].ruleId, "no-alert"); - * }); - */ - - /* - * it("should ignore violations only of specified rule", () => { - * const code = [ - * "// eslint-disable-next-line no-console", - * "alert('test');", - * "console.log('test');" - * ].join("\n"); - * const config = { - * rules: { - * "no-alert": 1, - * "no-console": 1 - * } - * }; - * const messages = linter.verify(code, config, filename); - */ - - /* - * assert.strictEqual(messages.length, 2); - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * assert.strictEqual(messages[1].ruleId, "no-console"); - * }); - */ - - /* - * it("should ignore violations of multiple rules when specified", () => { - * const code = [ - * "// eslint-disable-next-line no-alert, quotes", - * "alert(\"test\");", - * "console.log('test');" - * ].join("\n"); - * const config = { - * rules: { - * "no-alert": 1, - * quotes: [1, "single"], - * "no-console": 1 - * } - * }; - * const messages = linter.verify(code, config, filename); - */ - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].ruleId, "no-console"); - * }); - */ - - // it("should ignore violations of multiple rules when specified in mixed comments", () => { - // const code = [ - // "/* eslint-disable-next-line no-alert */ // eslint-disable-next-line quotes", - // "alert(\"test\");" - // ].join("\n"); - // const config = { - // rules: { - // "no-alert": 1, - // quotes: [1, "single"] - // } - // }; - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - /* - * it("should ignore violations of only the specified rule on next line", () => { - * const code = [ - * "// eslint-disable-next-line quotes", - * "alert(\"test\");", - * "console.log('test');" - * ].join("\n"); - * const config = { - * rules: { - * "no-alert": 1, - * quotes: [1, "single"], - * "no-console": 1 - * } - * }; - * const messages = linter.verify(code, config, filename); - */ - - /* - * assert.strictEqual(messages.length, 2); - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * assert.strictEqual(messages[1].ruleId, "no-console"); - * }); - */ - - /* - * it("should ignore violations of specified rule on next line only", () => { - * const code = [ - * "alert('test');", - * "// eslint-disable-next-line no-alert", - * "alert('test');", - * "console.log('test');" - * ].join("\n"); - * const config = { - * rules: { - * "no-alert": 1, - * "no-console": 1 - * } - * }; - * const messages = linter.verify(code, config, filename); - */ - - /* - * assert.strictEqual(messages.length, 2); - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * assert.strictEqual(messages[1].ruleId, "no-console"); - * }); - */ - - /* - * it("should ignore all rule violations on next line if none specified", () => { - * const code = [ - * "// eslint-disable-next-line", - * "alert(\"test\");", - * "console.log('test')" - * ].join("\n"); - * const config = { - * rules: { - * semi: [1, "never"], - * quotes: [1, "single"], - * "no-alert": 1, - * "no-console": 1 - * } - * }; - * const messages = linter.verify(code, config, filename); - */ - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].ruleId, "no-console"); - * }); - */ - - // it("should ignore violations if eslint-disable-next-line is a block comment", () => { - // const code = [ - // "alert('test');", - // "/* eslint-disable-next-line no-alert */", - // "alert('test');", - // "console.log('test');" - // ].join("\n"); - // const config = { - // rules: { - // "no-alert": 1, - // "no-console": 1 - // } - // }; - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 2); - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * assert.strictEqual(messages[1].ruleId, "no-console"); - * }); - */ - - // it("should report a violation", () => { - // const code = [ - // "/* eslint-disable-next-line", - // "*", - // "*/", - // "console.log('test');" // here - // ].join("\n"); - // const config = { - // rules: { - // "no-alert": 1, - // "no-console": 1 - // } - // }; - - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 2); - - /* - * assert.strictEqual(messages[1].ruleId, "no-console"); - * }); - */ - - /* - * it("should not ignore violations if comment is of the type Shebang", () => { - * const code = [ - * "#! eslint-disable-next-line no-alert", - * "alert('test');", - * "console.log('test');" - * ].join("\n"); - * const config = { - * rules: { - * "no-alert": 1, - * "no-console": 1 - * } - * }; - * const messages = linter.verify(code, config, filename); - */ - - /* - * assert.strictEqual(messages.length, 2); - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * assert.strictEqual(messages[1].ruleId, "no-console"); - * }); - * }); - * }); - */ - - // describe("when evaluating code with comments to enable and disable reporting of specific rules", () => { - - // it("should report a violation", () => { - // const code = [ - // "/*eslint-disable no-alert */", - // "alert('test');", - // "console.log('test');" // here - // ].join("\n"); - // const config = { rules: { "no-alert": 1, "no-console": 1 } }; - - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 1); - - /* - * assert.strictEqual(messages[0].ruleId, "no-console"); - * }); - */ - - // it("should report no violation", () => { - // const code = [ - // "/*eslint-disable no-unused-vars */", - // "var foo; // eslint-disable-line no-unused-vars", - // "var bar;", - // "/* eslint-enable no-unused-vars */" // here - // ].join("\n"); - // const config = { rules: { "no-unused-vars": 2 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - /* - * it("should report no violation", () => { - * const code = [ - * "var foo1; // eslint-disable-line no-unused-vars", - * "var foo2; // eslint-disable-line no-unused-vars", - * "var foo3; // eslint-disable-line no-unused-vars", - * "var foo4; // eslint-disable-line no-unused-vars", - * "var foo5; // eslint-disable-line no-unused-vars" - * ].join("\n"); - * const config = { rules: { "no-unused-vars": 2 } }; - */ - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - // it("should report no violation", () => { - // const code = [ - // "/* eslint-disable quotes */", - // "console.log(\"foo\");", - // "/* eslint-enable quotes */" - // ].join("\n"); - // const config = { rules: { quotes: 2 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - // it("should report a violation", () => { - // const code = [ - // "/*eslint-disable no-alert, no-console */", - // "alert('test');", - // "console.log('test');", - // "/*eslint-enable*/", - - /* - * "alert('test');", // here - * "console.log('test');" // here - * ].join("\n"); - * const config = { rules: { "no-alert": 1, "no-console": 1 } }; - */ - - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 2); - - /* - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * assert.strictEqual(messages[0].line, 5); - * assert.strictEqual(messages[1].ruleId, "no-console"); - * assert.strictEqual(messages[1].line, 6); - * }); - */ - - // it("should report a violation", () => { - // const code = [ - // "/*eslint-disable no-alert */", - // "alert('test');", - // "console.log('test');", - // "/*eslint-enable no-console */", - - /* - * "alert('test');" // here - * ].join("\n"); - * const config = { rules: { "no-alert": 1, "no-console": 1 } }; - */ - - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 1); - - /* - * assert.strictEqual(messages[0].ruleId, "no-console"); - * }); - */ - - - // it("should report a violation", () => { - // const code = [ - // "/*eslint-disable no-alert, no-console */", - // "alert('test');", - // "console.log('test');", - // "/*eslint-enable no-alert*/", - - /* - * "alert('test');", // here - * "console.log('test');" - * ].join("\n"); - * const config = { rules: { "no-alert": 1, "no-console": 1 } }; - */ - - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 1); - - /* - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * assert.strictEqual(messages[0].line, 5); - * }); - */ - - - // it("should report a violation", () => { - // const code = [ - // "/*eslint-disable no-alert */", - - // "/*eslint-disable no-console */", - // "alert('test');", - // "console.log('test');", - // "/*eslint-enable */", - - /* - * "alert('test');", // here - * "console.log('test');", // here - */ - - // "/*eslint-enable */", - - /* - * "alert('test');", // here - * "console.log('test');", // here - */ - - // "/*eslint-enable*/" - // ].join("\n"); - // const config = { rules: { "no-alert": 1, "no-console": 1 } }; - - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 4); - - /* - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * assert.strictEqual(messages[0].line, 6); - */ - - /* - * assert.strictEqual(messages[1].ruleId, "no-console"); - * assert.strictEqual(messages[1].line, 7); - */ - - /* - * assert.strictEqual(messages[2].ruleId, "no-alert"); - * assert.strictEqual(messages[2].line, 9); - */ - - /* - * assert.strictEqual(messages[3].ruleId, "no-console"); - * assert.strictEqual(messages[3].line, 10); - */ - - // }); - - // it("should report a violation", () => { - // const code = [ - // "/*eslint-disable no-alert, no-console */", - // "alert('test');", - // "console.log('test');", - - // "/*eslint-enable no-alert */", - - /* - * "alert('test');", // here - * "console.log('test');", - */ - - // "/*eslint-enable no-console */", - - // "alert('test');", // here - // "console.log('test');", // here - // "/*eslint-enable no-console */" - // ].join("\n"); - // const config = { rules: { "no-alert": 1, "no-console": 1 } }; - - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 3); - - /* - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * assert.strictEqual(messages[0].line, 5); - */ - - /* - * assert.strictEqual(messages[1].ruleId, "no-alert"); - * assert.strictEqual(messages[1].line, 8); - */ - - /* - * assert.strictEqual(messages[2].ruleId, "no-console"); - * assert.strictEqual(messages[2].line, 9); - */ - - // }); - - // it("should report a violation when severity is warn", () => { - // const code = [ - // "/*eslint-disable no-alert, no-console */", - // "alert('test');", - // "console.log('test');", - - // "/*eslint-enable no-alert */", - - /* - * "alert('test');", // here - * "console.log('test');", - */ - - // "/*eslint-enable no-console */", - - // "alert('test');", // here - // "console.log('test');", // here - // "/*eslint-enable no-console */" - // ].join("\n"); - // const config = { rules: { "no-alert": "warn", "no-console": "warn" } }; - - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 3); - - /* - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * assert.strictEqual(messages[0].line, 5); - */ - - /* - * assert.strictEqual(messages[1].ruleId, "no-alert"); - * assert.strictEqual(messages[1].line, 8); - */ - - /* - * assert.strictEqual(messages[2].ruleId, "no-console"); - * assert.strictEqual(messages[2].line, 9); - */ - - /* - * }); - * }); - */ - - // describe("when evaluating code with comments to enable and disable multiple comma separated rules", () => { - // const code = "/*eslint no-alert:1, no-console:0*/ alert('test'); console.log('test');"; - - /* - * it("should report a violation", () => { - * const config = { rules: { "no-console": 1, "no-alert": 0 } }; - */ - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * assert.strictEqual(messages[0].message, "Unexpected alert."); - * assert.include(messages[0].nodeType, "CallExpression"); - * }); - * }); - */ - - // describe("when evaluating code with comments to enable configurable rule", () => { - // const code = "/*eslint quotes:[2, \"double\"]*/ alert('test');"; - - /* - * it("should report a violation", () => { - * const config = { rules: { quotes: [2, "single"] } }; - */ - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].ruleId, "quotes"); - * assert.strictEqual(messages[0].message, "Strings must use doublequote."); - * assert.include(messages[0].nodeType, "Literal"); - * }); - * }); - */ - - // describe("when evaluating code with comments to enable configurable rule using string severity", () => { - // const code = "/*eslint quotes:[\"error\", \"double\"]*/ alert('test');"; - - /* - * it("should report a violation", () => { - * const config = { rules: { quotes: [2, "single"] } }; - */ - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].ruleId, "quotes"); - * assert.strictEqual(messages[0].message, "Strings must use doublequote."); - * assert.include(messages[0].nodeType, "Literal"); - * }); - * }); - */ - - // describe("when evaluating code with incorrectly formatted comments to disable rule", () => { - // it("should report a violation", () => { - // const code = "/*eslint no-alert:'1'*/ alert('test');"; - - // const config = { rules: { "no-alert": 1 } }; - - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 2); - - // /* - // * Incorrectly formatted comment threw error; - // * message from caught exception - // * may differ amongst UAs, so verifying - // * first part only as defined in the - // * parseJsonConfig function in lib/eslint.js - // */ - // assert.match(messages[0].message, /^Failed to parse JSON from ' "no-alert":'1'':/); - // assert.strictEqual(messages[0].line, 1); - // assert.strictEqual(messages[0].column, 1); - - /* - * assert.strictEqual(messages[1].ruleId, "no-alert"); - * assert.strictEqual(messages[1].message, "Unexpected alert."); - * assert.include(messages[1].nodeType, "CallExpression"); - * }); - */ - - // it("should report a violation", () => { - // const code = "/*eslint no-alert:abc*/ alert('test');"; - - // const config = { rules: { "no-alert": 1 } }; - - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 2); - - // /* - // * Incorrectly formatted comment threw error; - // * message from caught exception - // * may differ amongst UAs, so verifying - // * first part only as defined in the - // * parseJsonConfig function in lib/eslint.js - // */ - // assert.match(messages[0].message, /^Failed to parse JSON from ' "no-alert":abc':/); - // assert.strictEqual(messages[0].line, 1); - // assert.strictEqual(messages[0].column, 1); - - /* - * assert.strictEqual(messages[1].ruleId, "no-alert"); - * assert.strictEqual(messages[1].message, "Unexpected alert."); - * assert.include(messages[1].nodeType, "CallExpression"); - * }); - */ - - // it("should report a violation", () => { - // const code = "/*eslint no-alert:0 2*/ alert('test');"; - - // const config = { rules: { "no-alert": 1 } }; - - // const messages = linter.verify(code, config, filename); - - // assert.strictEqual(messages.length, 2); - - // /* - // * Incorrectly formatted comment threw error; - // * message from caught exception - // * may differ amongst UAs, so verifying - // * first part only as defined in the - // * parseJsonConfig function in lib/eslint.js - // */ - // assert.match(messages[0].message, /^Failed to parse JSON from ' "no-alert":0 2':/); - // assert.strictEqual(messages[0].line, 1); - // assert.strictEqual(messages[0].column, 1); - - /* - * assert.strictEqual(messages[1].ruleId, "no-alert"); - * assert.strictEqual(messages[1].message, "Unexpected alert."); - * assert.include(messages[1].nodeType, "CallExpression"); - * }); - * }); - */ - - // describe("when evaluating code with comments which have colon in its value", () => { - // const code = "/* eslint max-len: [2, 100, 2, {ignoreUrls: true, ignorePattern: \"data:image\\/|\\s*require\\s*\\(|^\\s*loader\\.lazy|-\\*-\"}] */\nalert('test');"; - - /* - * it("should not parse errors, should report a violation", () => { - * const messages = linter.verify(code, {}, filename); - */ - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].ruleId, "max-len"); - * assert.strictEqual(messages[0].message, "Line 1 exceeds the maximum line length of 100."); - * assert.include(messages[0].nodeType, "Program"); - * }); - * }); - */ - - /* - * describe("when evaluating a file with a shebang", () => { - * const code = "#!bin/program\n\nvar foo;;"; - */ - - /* - * it("should preserve line numbers", () => { - * const config = { rules: { "no-extra-semi": 1 } }; - * const messages = linter.verify(code, config); - */ - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].ruleId, "no-extra-semi"); - * assert.strictEqual(messages[0].nodeType, "EmptyStatement"); - * assert.strictEqual(messages[0].line, 3); - * }); - */ - - /* - * it("should have a comment with the shebang in it", () => { - * const config = { rules: { checker: "error" } }; - * const spy = sandbox.spy(context => { - * const comments = context.getAllComments(); - */ - - /* - * assert.strictEqual(comments.length, 1); - * assert.strictEqual(comments[0].type, "Shebang"); - * return {}; - * }); - */ - - /* - * linter.defineRule("checker", spy); - * linter.verify(code, config); - * assert(spy.calledOnce); - * }); - * }); - */ - - /* - * describe("when evaluating broken code", () => { - * const code = BROKEN_TEST_CODE; - */ - - /* - * it("should report a violation with a useful parse error prefix", () => { - * const messages = linter.verify(code); - */ - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].severity, 2); - * assert.isNull(messages[0].ruleId); - * assert.strictEqual(messages[0].line, 1); - * assert.strictEqual(messages[0].column, 4); - * assert.isTrue(messages[0].fatal); - * assert.match(messages[0].message, /^Parsing error:/); - * }); - */ - - /* - * it("should report source code where the issue is present", () => { - * const inValidCode = [ - * "var x = 20;", - * "if (x ==4 {", - * " x++;", - * "}" - * ]; - * const messages = linter.verify(inValidCode.join("\n")); - */ - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].severity, 2); - * assert.isTrue(messages[0].fatal); - * assert.match(messages[0].message, /^Parsing error:/); - * }); - * }); - */ - - /* - * describe("when using an invalid (undefined) rule", () => { - * linter = new Linter(); - */ - - /* - * const code = TEST_CODE; - * const results = linter.verify(code, { rules: { foobar: 2 } }); - * const result = results[0]; - * const warningResult = linter.verify(code, { rules: { foobar: 1 } })[0]; - * const arrayOptionResults = linter.verify(code, { rules: { foobar: [2, "always"] } }); - * const objectOptionResults = linter.verify(code, { rules: { foobar: [1, { bar: false }] } }); - * const resultsMultiple = linter.verify(code, { rules: { foobar: 2, barfoo: 1 } }); - */ - - /* - * it("should add a stub rule", () => { - * assert.isNotNull(result); - * assert.isArray(results); - * assert.isObject(result); - * assert.property(result, "ruleId"); - * assert.strictEqual(result.ruleId, "foobar"); - * }); - */ - - /* - * it("should report that the rule does not exist", () => { - * assert.property(result, "message"); - * assert.strictEqual(result.message, "Definition for rule 'foobar' was not found"); - * }); - */ - - /* - * it("should report at the correct severity", () => { - * assert.property(result, "severity"); - * assert.strictEqual(result.severity, 2); - * assert.strictEqual(warningResult.severity, 1); - * }); - */ - - /* - * it("should accept any valid rule configuration", () => { - * assert.isObject(arrayOptionResults[0]); - * assert.isObject(objectOptionResults[0]); - * }); - */ - - /* - * it("should report multiple missing rules", () => { - * assert.isArray(resultsMultiple); - */ - - /* - * assert.deepStrictEqual( - * resultsMultiple[1], - * { - * ruleId: "barfoo", - * message: "Definition for rule 'barfoo' was not found", - * line: 1, - * column: 1, - * severity: 1, - * nodeType: null - * } - * ); - * }); - * }); - */ - - /* - * describe("when using a rule which has been replaced", () => { - * const code = TEST_CODE; - * const results = linter.verify(code, { rules: { "no-comma-dangle": 2 } }); - */ - - /* - * it("should report the new rule", () => { - * assert.strictEqual(results[0].ruleId, "no-comma-dangle"); - * assert.strictEqual(results[0].message, "Rule 'no-comma-dangle' was removed and replaced by: comma-dangle"); - * }); - * }); - */ - - /* - * describe("when calling getRules", () => { - * it("should return all loaded rules", () => { - * const rules = linter.getRules(); - */ - - /* - * assert.isAbove(rules.size, 230); - * assert.isObject(rules.get("no-alert")); - * }); - * }); - */ - - /* - * describe("when calling version", () => { - * it("should return current version number", () => { - * const version = linter.version; - */ - - /* - * assert.isString(version); - * assert.isTrue(parseInt(version[0], 10) >= 3); - * }); - * }); - */ - - /* - * describe("when evaluating an empty string", () => { - * it("runs rules", () => { - * linter.defineRule("no-programs", context => ({ - * Program(node) { - * context.report({ node, message: "No programs allowed." }); - * } - * })); - */ - - /* - * assert.strictEqual( - * linter.verify("", { rules: { "no-programs": "error" } }).length, - * 1 - * ); - * }); - * }); - */ - - /* - * describe("when evaluating code without comments to environment", () => { - * it("should report a violation when using typed array", () => { - * const code = "var array = new Uint8Array();"; - */ - - // const config = { rules: { "no-undef": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 1); - * }); - */ - - /* - * it("should report a violation when using Promise", () => { - * const code = "new Promise();"; - */ - - // const config = { rules: { "no-undef": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 1); - * }); - * }); - */ - - // describe("when evaluating code with comments to environment", () => { - // it("should not support legacy config", () => { - // const code = "/*jshint mocha:true */ describe();"; - - // const config = { rules: { "no-undef": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].ruleId, "no-undef"); - * assert.strictEqual(messages[0].nodeType, "Identifier"); - * assert.strictEqual(messages[0].line, 1); - * }); - */ - - // it("should not report a violation", () => { - // const code = "/*eslint-env es6 */ new Promise();"; - - // const config = { rules: { "no-undef": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - // it("should not report a violation", () => { - // const code = "/*eslint-env mocha,node */ require();describe();"; - - // const config = { rules: { "no-undef": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - // it("should not report a violation", () => { - // const code = "/*eslint-env mocha */ suite();test();"; - - // const config = { rules: { "no-undef": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - // it("should not report a violation", () => { - // const code = "/*eslint-env amd */ define();require();"; - - // const config = { rules: { "no-undef": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - // it("should not report a violation", () => { - // const code = "/*eslint-env jasmine */ expect();spyOn();"; - - // const config = { rules: { "no-undef": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - // it("should not report a violation", () => { - // const code = "/*globals require: true */ /*eslint-env node */ require = 1;"; - - // const config = { rules: { "no-undef": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - // it("should not report a violation", () => { - // const code = "/*eslint-env node */ process.exit();"; - - // const config = { rules: {} }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - // it("should not report a violation", () => { - // const code = "/*eslint no-process-exit: 0 */ /*eslint-env node */ process.exit();"; - - // const config = { rules: { "no-undef": 1 } }; - - // const messages = linter.verify(code, config, filename); - - /* - * assert.strictEqual(messages.length, 0); - * }); - * }); - */ - - /* - * describe("when evaluating code with comments to change config when allowInlineConfig is enabled", () => { - * it("should report a violation for disabling rules", () => { - * const code = [ - * "alert('test'); // eslint-disable-line no-alert" - * ].join("\n"); - * const config = { - * rules: { - * "no-alert": 1 - * } - * }; - */ - - /* - * const messages = linter.verify(code, config, { - * filename, - * allowInlineConfig: false - * }); - */ - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * }); - */ - - // it("should report a violation for global variable declarations", () => { - // const code = [ - // "/* global foo */" - // ].join("\n"); - // const config = { - // rules: { - // test: 2 - // } - // }; - // let ok = false; - - /* - * linter.defineRules({ - * test(context) { - * return { - * Program() { - * const scope = context.getScope(); - * const sourceCode = context.getSourceCode(); - * const comments = sourceCode.getAllComments(); - */ - - // assert.strictEqual(1, comments.length); - - // const foo = getVariable(scope, "foo"); - - // assert.notOk(foo); - - /* - * ok = true; - * } - * }; - * } - * }); - */ - - /* - * linter.verify(code, config, { allowInlineConfig: false }); - * assert(ok); - * }); - */ - - // it("should report a violation for eslint-disable", () => { - // const code = [ - // "/* eslint-disable */", - // "alert('test');" - // ].join("\n"); - // const config = { - // rules: { - // "no-alert": 1 - // } - // }; - - /* - * const messages = linter.verify(code, config, { - * filename, - * allowInlineConfig: false - * }); - */ - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * }); - */ - - // it("should not report a violation for rule changes", () => { - // const code = [ - // "/*eslint no-alert:2*/", - // "alert('test');" - // ].join("\n"); - // const config = { - // rules: { - // "no-alert": 0 - // } - // }; - - /* - * const messages = linter.verify(code, config, { - * filename, - * allowInlineConfig: false - * }); - */ - - /* - * assert.strictEqual(messages.length, 0); - * }); - */ - - /* - * it("should report a violation for disable-line", () => { - * const code = [ - * "alert('test'); // eslint-disable-line" - * ].join("\n"); - * const config = { - * rules: { - * "no-alert": 2 - * } - * }; - */ - - /* - * const messages = linter.verify(code, config, { - * filename, - * allowInlineConfig: false - * }); - */ - - /* - * assert.strictEqual(messages.length, 1); - * assert.strictEqual(messages[0].ruleId, "no-alert"); - * }); - */ - - // it("should report a violation for env changes", () => { - // const code = [ - // "/*eslint-env browser*/" - // ].join("\n"); - // const config = { - // rules: { - // test: 2 - // } - // }; - // let ok = false; - - /* - * linter.defineRules({ - * test(context) { - * return { - * Program() { - * const scope = context.getScope(); - * const sourceCode = context.getSourceCode(); - * const comments = sourceCode.getAllComments(); - */ - - // assert.strictEqual(1, comments.length); - - // const windowVar = getVariable(scope, "window"); - - // assert.notOk(windowVar.eslintExplicitGlobal); - - /* - * ok = true; - * } - * }; - * } - * }); - */ - - /* - * linter.verify(code, config, { allowInlineConfig: false }); - * assert(ok); - * }); - * }); - */ - - // describe("reportUnusedDisable option", () => { - // it("reports problems for unused eslint-disable comments", () => { - // assert.deepStrictEqual( - // linter.verify("/* eslint-disable */", {}, { reportUnusedDisableDirectives: true }), - // [ - // { - // ruleId: null, - // message: "Unused eslint-disable directive (no problems were reported).", - // line: 1, - // column: 1, - // severity: 2, - // nodeType: null - // } - // ] - // ); - // }); - // }); - - /* - * describe("when evaluating code with comments to change config when allowInlineConfig is disabled", () => { - * it("should not report a violation", () => { - * const code = [ - * "alert('test'); // eslint-disable-line no-alert" - * ].join("\n"); - * const config = { - * rules: { - * "no-alert": 1 - * } - * }; - */ - - /* - * const messages = linter.verify(code, config, { - * filename, - * allowInlineConfig: true - * }); - */ - - /* - * assert.strictEqual(messages.length, 0); - * }); - * }); - */ - }); From 2fea543773ab0b2b935c48b292d5955f6a63327a Mon Sep 17 00:00:00 2001 From: "Nicholas C. Zakas" Date: Mon, 19 Nov 2018 09:51:52 -0800 Subject: [PATCH 5/6] Add comment to updated test --- tests/lib/util/npm-utils.js | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/tests/lib/util/npm-utils.js b/tests/lib/util/npm-utils.js index 4c615abc61f..1be803627b0 100644 --- a/tests/lib/util/npm-utils.js +++ b/tests/lib/util/npm-utils.js @@ -162,6 +162,13 @@ describe("npmUtils", () => { }); it("should return false if package.json does not exist", () => { + /* + * Checking local file system directly, which does not + * contains package.json. This is necessary because mock-fs + * doesn't work in Node.js 11: it throws an error when + * a file is missing rather than returning false. + * TODO: Find a replacement for mock-fs that works in Node 11. + */ assert.strictEqual(npmUtils.checkPackageJson("/"), false); }); }); From 487ebfeece5015fe803421a350893b44804f0769 Mon Sep 17 00:00:00 2001 From: "Nicholas C. Zakas" Date: Mon, 19 Nov 2018 09:57:19 -0800 Subject: [PATCH 6/6] Fix lint issue --- tests/lib/util/npm-utils.js | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/lib/util/npm-utils.js b/tests/lib/util/npm-utils.js index 1be803627b0..5c8e4cc845e 100644 --- a/tests/lib/util/npm-utils.js +++ b/tests/lib/util/npm-utils.js @@ -162,6 +162,7 @@ describe("npmUtils", () => { }); it("should return false if package.json does not exist", () => { + /* * Checking local file system directly, which does not * contains package.json. This is necessary because mock-fs