From 1297ab6d91679a68b4c37834dc303a741cd13844 Mon Sep 17 00:00:00 2001 From: Tony Brix Date: Mon, 21 Mar 2022 01:26:15 -0500 Subject: [PATCH] fix: detect ESLint >= 8 and tell the user about linter-eslint-node (#1464) Co-Authored-By: Tony Brix --- README.md | 6 +- dist/worker-helpers.js | 2 +- package.json | 9 ++- .../lib/node_modules/eslint/lib/api.js | 2 +- .../node_modules/eslint/lib/api.js | 1 + .../node_modules/eslint/package.json | 1 + .../eslint/node_modules/eslint/lib/api.js | 2 +- .../node_modules/eslint/lib/api.js | 2 +- spec/worker-helpers-spec.js | 17 ++++-- src/helpers.js | 60 ++++++++++++++++++- src/main.js | 17 ++++++ src/worker-helpers.js | 40 ++++++++++++- src/worker.js | 6 +- 13 files changed, 149 insertions(+), 16 deletions(-) create mode 100644 spec/fixtures/incompatible-eslint/node_modules/eslint/lib/api.js create mode 100644 spec/fixtures/incompatible-eslint/node_modules/eslint/package.json diff --git a/README.md b/README.md index c2e9f3b4..72b0d4f7 100644 --- a/README.md +++ b/README.md @@ -4,9 +4,11 @@ [![Dependency Status](https://david-dm.org/AtomLinter/linter-eslint.svg)](https://david-dm.org/AtomLinter/linter-eslint) This linter plugin for [Linter](https://github.com/AtomLinter/Linter) provides -an interface to [eslint](http://eslint.org). It will be used with files that +an interface to [eslint](http://eslint.org) versions 7 and below. It will be used with files that have the "JavaScript" syntax. +**For linting in projects that use ESLint v8 and above, install [linter-eslint-node](https://atom.io/packages/linter-eslint-node).** + ## Installation ```ShellSession @@ -24,7 +26,7 @@ This package requires an `eslint` of at least v1.0.0. If you do not have the `linter` package installed, it will be installed -for you. If you are using an alternative `linter-*` consumer, +for you. If you are using an alternative `linter-*` consumer, the `linter` package can be disabled. If you wish to lint files in JavaScript-derivative languages (like Typescript, diff --git a/dist/worker-helpers.js b/dist/worker-helpers.js index 68bcdf17..41a15d90 100644 --- a/dist/worker-helpers.js +++ b/dist/worker-helpers.js @@ -332,4 +332,4 @@ function getRules(cliEngine) { function didRulesChange(currentRules, newRules) { return !(currentRules.size === newRules.size && Array.from(currentRules.keys()).every(ruleId => newRules.has(ruleId))); } -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/worker-helpers.js"],"names":["Cache","ESLINT_LOCAL_PATH","Path","normalize","join","__dirname","NODE_PREFIX_PATH","LAST_MODULES_PATH","cleanPath","path","fs","getNodePrefixPath","npmCommand","process","platform","ChildProcess","spawnSync","env","PATH","output","toString","trim","e","errMsg","Error","isDirectory","dirPath","isDir","statSync","fallbackForGlobalErrorThrown","findESLintDirectory","modulesDir","config","projectPath","fallbackForGlobal","eslintDir","locationType","global","useGlobalEslint","configGlobal","globalNodePath","prefixPath","advanced","localNodeModules","isAbsolute","type","console","error","getESLintFromDirectory","ESLintDirectory","require","code","refreshModulesPath","NODE_PATH","Module","_initPaths","getESLintInstance","fileDir","dirname","log","args","obj","length","str","JSON","stringify","Util","inspect","emit","getConfigForFile","eslint","filePath","cli","CLIEngine","getRelativePath","ignoreFile","disableEslintIgnore","ignoreDir","chdir","relative","basename","getCLIEngineOptions","rules","fileConfig","cliEngineConfig","ignore","fix","rulePaths","eslintRulesDirs","map","rulesDir","filter","eslintrcPath","configFile","getRules","cliEngine","Object","prototype","hasOwnProperty","call","linter","Map","didRulesChange","currentRules","newRules","size","Array","from","keys","every","ruleId","has"],"mappings":"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","sourcesContent":["/* global emit */\n\nimport Path from 'path'\nimport Util from 'util'\nimport fs from 'fs-plus'\nimport ChildProcess from 'child_process'\nimport resolveEnv from 'resolve-env'\nimport { findCached } from 'atom-linter'\nimport getPath from 'consistent-path'\n\nconst Cache = {\n  ESLINT_LOCAL_PATH: Path.normalize(Path.join(__dirname, '..', 'node_modules', 'eslint')),\n  NODE_PREFIX_PATH: null,\n  LAST_MODULES_PATH: null\n}\n\n/**\n * Takes a path and translates `~` to the user's home directory, and replaces\n * all environment variables with their value.\n * @param  {string} path The path to remove \"strangeness\" from\n * @return {string}      The cleaned path\n */\nconst cleanPath = (path) => (path ? resolveEnv(fs.normalize(path)) : '')\n\n/**\n * @returns {string}\n */\nexport function getNodePrefixPath() {\n  if (Cache.NODE_PREFIX_PATH === null) {\n    const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm'\n    try {\n      Cache.NODE_PREFIX_PATH = ChildProcess.spawnSync(npmCommand, ['get', 'prefix'], {\n        env: { ...process.env, PATH: getPath() }\n      }).output[1].toString().trim()\n    } catch (e) {\n      const errMsg = 'Unable to execute `npm get prefix`. Please make sure '\n        + 'Atom is getting $PATH correctly.'\n      throw new Error(errMsg)\n    }\n  }\n  return Cache.NODE_PREFIX_PATH\n}\n\n/**\n * @param {string} dirPath\n * @returns {boolean}\n */\nfunction isDirectory(dirPath) {\n  let isDir\n  try {\n    isDir = fs.statSync(dirPath).isDirectory()\n  } catch (e) {\n    isDir = false\n  }\n  return isDir\n}\n\nlet fallbackForGlobalErrorThrown = false\n\n/**\n * @param {string} modulesDir\n * @param {object} config\n * @param {string} projectPath\n * @param {boolean} fallbackForGlobal\n * @returns {{ path: string, type: 'local project' | 'global' | 'advanced specified' | 'bundled fallback' }}\n */\nexport function findESLintDirectory(modulesDir, config, projectPath, fallbackForGlobal = false) {\n  let eslintDir = null\n  let locationType = null\n  if (config.global.useGlobalEslint && !fallbackForGlobal) {\n    locationType = 'global'\n    const configGlobal = cleanPath(config.global.globalNodePath)\n    const prefixPath = configGlobal || getNodePrefixPath()\n    // NPM on Windows and Yarn on all platforms\n    eslintDir = Path.join(prefixPath, 'node_modules', 'eslint')\n    if (!isDirectory(eslintDir)) {\n      // NPM on platforms other than Windows\n      eslintDir = Path.join(prefixPath, 'lib', 'node_modules', 'eslint')\n    }\n  } else if (!config.advanced.localNodeModules) {\n    locationType = 'local project'\n    eslintDir = Path.join(modulesDir || '', 'eslint')\n  } else if (Path.isAbsolute(cleanPath(config.advanced.localNodeModules))) {\n    locationType = 'advanced specified'\n    eslintDir = Path.join(cleanPath(config.advanced.localNodeModules), 'eslint')\n  } else {\n    locationType = 'advanced specified'\n    eslintDir = Path.join(projectPath || '', cleanPath(config.advanced.localNodeModules), 'eslint')\n  }\n\n  if (isDirectory(eslintDir)) {\n    return {\n      path: eslintDir,\n      type: locationType,\n    }\n  }\n\n  if (config.global.useGlobalEslint && !fallbackForGlobal) {\n    if (!fallbackForGlobalErrorThrown) {\n      // Throw the error only once to prevent performance issues\n      fallbackForGlobalErrorThrown = true\n      console.error(`Global ESLint is not found, falling back to other Eslint installations...\n        Please ensure the global Node path is set correctly.\n        If you wanted to use a local installation of Eslint, disable Global Eslint option in the linter-eslint config.`)\n    }\n    return findESLintDirectory(modulesDir, config, projectPath, true)\n  }\n\n  return {\n    path: Cache.ESLINT_LOCAL_PATH,\n    type: 'bundled fallback',\n  }\n}\n\n/**\n * @param {string} modulesDir\n * @param {object} config\n * @param {string} projectPath\n * @returns {import(\"eslint\")}\n */\nexport function getESLintFromDirectory(modulesDir, config, projectPath) {\n  const { path: ESLintDirectory } = findESLintDirectory(modulesDir, config, projectPath)\n  try {\n    // eslint-disable-next-line import/no-dynamic-require\n    return require(ESLintDirectory)\n  } catch (e) {\n    if (config.global.useGlobalEslint && e.code === 'MODULE_NOT_FOUND') {\n      throw new Error('ESLint not found, try restarting Atom to clear caches.')\n    }\n    // eslint-disable-next-line import/no-dynamic-require\n    return require(Cache.ESLINT_LOCAL_PATH)\n  }\n}\n\n/**\n * @param {string} modulesDir\n */\nexport function refreshModulesPath(modulesDir) {\n  if (Cache.LAST_MODULES_PATH !== modulesDir) {\n    Cache.LAST_MODULES_PATH = modulesDir\n    process.env.NODE_PATH = modulesDir || ''\n    // eslint-disable-next-line no-underscore-dangle\n    require('module').Module._initPaths()\n  }\n}\n\n/**\n * @param {string} fileDir\n * @param {object} config\n * @param {string} projectPath\n * @returns {import(\"eslint\")}\n */\nexport function getESLintInstance(fileDir, config, projectPath) {\n  const modulesDir = Path.dirname(findCached(fileDir, 'node_modules/eslint') || '')\n  refreshModulesPath(modulesDir)\n  return getESLintFromDirectory(modulesDir, config, projectPath)\n}\n\n/**\n * console.log\n * @param  {any} args\n * @return {void}\n */\nexport function log(...args) {\n  const obj = args.length === 1 ? args[0] : args\n  let str\n  try {\n    str = JSON.stringify(obj)\n  } catch (e) {\n    str = Util.inspect(obj)\n  }\n\n  emit('log', str)\n}\n\n/**\n * @param {import(\"eslint\")} eslint\n * @param {string} filePath\n */\nexport function getConfigForFile(eslint, filePath) {\n  const cli = new eslint.CLIEngine()\n  try {\n    return cli.getConfigForFile(filePath)\n  } catch (e) {\n    // No configuration was found\n    return null\n  }\n}\n\n/**\n * @param {string} fileDir\n * @param {string} filePath\n * @param {object} config\n * @param {string} projectPath\n * @returns {string}\n */\nexport function getRelativePath(fileDir, filePath, config, projectPath) {\n  const ignoreFile = config.advanced.disableEslintIgnore ? null : findCached(fileDir, '.eslintignore')\n\n  // If we can find an .eslintignore file, we can set cwd there\n  // (because they are expected to be at the project root)\n  if (ignoreFile) {\n    const ignoreDir = Path.dirname(ignoreFile)\n    process.chdir(ignoreDir)\n    return Path.relative(ignoreDir, filePath)\n  }\n  // Otherwise, we'll set the cwd to the atom project root as long as that exists\n  if (projectPath) {\n    process.chdir(projectPath)\n    return Path.relative(projectPath, filePath)\n  }\n  // If all else fails, use the file location itself\n  process.chdir(fileDir)\n  return Path.basename(filePath)\n}\n\n/**\n * @param {string} type\n * @param {string[]} rules\n * @param {object} config\n * @param {string} filePath\n * @param {object} fileConfig\n */\nexport function getCLIEngineOptions(type, config, rules, filePath, fileConfig) {\n  const cliEngineConfig = {\n    rules,\n    ignore: !config.advanced.disableEslintIgnore,\n    fix: type === 'fix'\n  }\n\n  cliEngineConfig.rulePaths = config.advanced.eslintRulesDirs.map((path) => {\n    const rulesDir = cleanPath(path)\n    if (!Path.isAbsolute(rulesDir)) {\n      return findCached(Path.dirname(filePath), rulesDir)\n    }\n    return rulesDir\n  }).filter((path) => path)\n\n  if (fileConfig === null && config.global.eslintrcPath) {\n    // If we didn't find a configuration use the fallback from the settings\n    cliEngineConfig.configFile = cleanPath(config.global.eslintrcPath)\n  }\n\n  return cliEngineConfig\n}\n\n/**\n * Gets the list of rules used for a lint job\n * @param  {import(\"eslint\").CLIEngine} cliEngine The CLIEngine instance used for the lint job\n * @return {Map}              A Map of the rules used, rule names as keys, rule\n *                            properties as the contents.\n */\nexport function getRules(cliEngine) {\n  // Pull the list of rules used directly from the CLIEngine\n  if (typeof cliEngine.getRules === 'function') {\n    return cliEngine.getRules()\n  }\n\n  // Attempt to use the internal (undocumented) `linter` instance attached to\n  // the CLIEngine to get the loaded rules (including plugin rules).\n  // Added in ESLint v4\n  if (Object.prototype.hasOwnProperty.call(cliEngine, 'linter')) {\n    return cliEngine.linter.getRules()\n  }\n\n  // Older versions of ESLint don't (easily) support getting a list of rules\n  return new Map()\n}\n\n/**\n * Given an exiting rule list and a new rule list, determines whether there\n * have been changes.\n * NOTE: This only accounts for presence of the rules, changes to their metadata\n * are not taken into account.\n * @param  {Map} newRules     A Map of the new rules\n * @param  {Map} currentRules A Map of the current rules\n * @return {boolean}             Whether or not there were changes\n */\nexport function didRulesChange(currentRules, newRules) {\n  return !(currentRules.size === newRules.size\n    && Array.from(currentRules.keys()).every((ruleId) => newRules.has(ruleId)))\n}\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/worker-helpers.js"],"names":["Cache","ESLINT_LOCAL_PATH","Path","normalize","join","__dirname","NODE_PREFIX_PATH","LAST_MODULES_PATH","cleanPath","path","fs","getNodePrefixPath","npmCommand","process","platform","ChildProcess","spawnSync","env","PATH","output","toString","trim","e","errMsg","Error","isDirectory","dirPath","isDir","statSync","fallbackForGlobalErrorThrown","findESLintDirectory","modulesDir","config","projectPath","fallbackForGlobal","eslintDir","locationType","global","useGlobalEslint","configGlobal","globalNodePath","prefixPath","advanced","localNodeModules","isAbsolute","type","console","error","getESLintFromDirectory","ESLintDirectory","require","code","refreshModulesPath","NODE_PATH","Module","_initPaths","getESLintInstance","fileDir","dirname","log","args","obj","length","str","JSON","stringify","Util","inspect","emit","getConfigForFile","eslint","filePath","cli","CLIEngine","getRelativePath","ignoreFile","disableEslintIgnore","ignoreDir","chdir","relative","basename","getCLIEngineOptions","rules","fileConfig","cliEngineConfig","ignore","fix","rulePaths","eslintRulesDirs","map","rulesDir","filter","eslintrcPath","configFile","getRules","cliEngine","Object","prototype","hasOwnProperty","call","linter","Map","didRulesChange","currentRules","newRules","size","Array","from","keys","every","ruleId","has"],"mappings":"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","sourcesContent":["/* global emit */\n\nimport Path from 'path';\nimport Util from 'util';\nimport fs from 'fs-plus'\nimport ChildProcess from 'child_process'\nimport resolveEnv from 'resolve-env'\nimport { findCached } from 'atom-linter'\nimport getPath from 'consistent-path'\n\nconst Cache = {\n  ESLINT_LOCAL_PATH: Path.normalize(Path.join(__dirname, '..', 'node_modules', 'eslint')),\n  NODE_PREFIX_PATH: null,\n  LAST_MODULES_PATH: null\n}\n\n/**\n * Takes a path and translates `~` to the user's home directory, and replaces\n * all environment variables with their value.\n * @param  {string} path The path to remove \"strangeness\" from\n * @return {string}      The cleaned path\n */\nconst cleanPath = (path) => (path ? resolveEnv(fs.normalize(path)) : '')\n\n/**\n * @returns {string}\n */\nexport function getNodePrefixPath() {\n  if (Cache.NODE_PREFIX_PATH === null) {\n    const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm'\n    try {\n      Cache.NODE_PREFIX_PATH = ChildProcess.spawnSync(npmCommand, ['get', 'prefix'], {\n        env: { ...process.env, PATH: getPath() }\n      }).output[1].toString().trim()\n    } catch (e) {\n      const errMsg = 'Unable to execute `npm get prefix`. Please make sure '\n        + 'Atom is getting $PATH correctly.'\n      throw new Error(errMsg)\n    }\n  }\n  return Cache.NODE_PREFIX_PATH\n}\n\n/**\n * @param {string} dirPath\n * @returns {boolean}\n */\nfunction isDirectory(dirPath) {\n  let isDir\n  try {\n    isDir = fs.statSync(dirPath).isDirectory()\n  } catch (e) {\n    isDir = false\n  }\n  return isDir\n}\n\nlet fallbackForGlobalErrorThrown = false\n\n/**\n * @param {string} modulesDir\n * @param {object} config\n * @param {string} projectPath\n * @param {boolean} fallbackForGlobal\n * @returns {{ path: string, type: 'local project' | 'global' | 'advanced specified' | 'bundled fallback' }}\n */\nexport function findESLintDirectory(modulesDir, config, projectPath, fallbackForGlobal = false) {\n  let eslintDir = null\n  let locationType = null\n  if (config.global.useGlobalEslint && !fallbackForGlobal) {\n    locationType = 'global'\n    const configGlobal = cleanPath(config.global.globalNodePath)\n    const prefixPath = configGlobal || getNodePrefixPath()\n    // NPM on Windows and Yarn on all platforms\n    eslintDir = Path.join(prefixPath, 'node_modules', 'eslint')\n    if (!isDirectory(eslintDir)) {\n      // NPM on platforms other than Windows\n      eslintDir = Path.join(prefixPath, 'lib', 'node_modules', 'eslint')\n    }\n  } else if (!config.advanced.localNodeModules) {\n    locationType = 'local project'\n    eslintDir = Path.join(modulesDir || '', 'eslint')\n  } else if (Path.isAbsolute(cleanPath(config.advanced.localNodeModules))) {\n    locationType = 'advanced specified'\n    eslintDir = Path.join(cleanPath(config.advanced.localNodeModules), 'eslint')\n  } else {\n    locationType = 'advanced specified'\n    eslintDir = Path.join(projectPath || '', cleanPath(config.advanced.localNodeModules), 'eslint')\n  }\n\n  if (isDirectory(eslintDir)) {\n    return {\n      path: eslintDir,\n      type: locationType,\n    }\n  }\n\n  if (config.global.useGlobalEslint && !fallbackForGlobal) {\n    if (!fallbackForGlobalErrorThrown) {\n      // Throw the error only once to prevent performance issues\n      fallbackForGlobalErrorThrown = true\n      console.error(`Global ESLint is not found, falling back to other Eslint installations...\n        Please ensure the global Node path is set correctly.\n        If you wanted to use a local installation of Eslint, disable Global Eslint option in the linter-eslint config.`)\n    }\n    return findESLintDirectory(modulesDir, config, projectPath, true)\n  }\n\n  return {\n    path: Cache.ESLINT_LOCAL_PATH,\n    type: 'bundled fallback',\n  }\n}\n\n/**\n * @param {string} modulesDir\n * @param {object} config\n * @param {string} projectPath\n * @returns {import(\"eslint\")}\n */\nexport function getESLintFromDirectory(modulesDir, config, projectPath) {\n  const { path: ESLintDirectory } = findESLintDirectory(modulesDir, config, projectPath)\n  try {\n    // eslint-disable-next-line import/no-dynamic-require\n    return require(ESLintDirectory)\n  } catch (e) {\n    if (config.global.useGlobalEslint && e.code === 'MODULE_NOT_FOUND') {\n      throw new Error('ESLint not found, try restarting Atom to clear caches.')\n    }\n    // eslint-disable-next-line import/no-dynamic-require\n    return require(Cache.ESLINT_LOCAL_PATH)\n  }\n}\n\n/**\n * @param {string} modulesDir\n */\nexport function refreshModulesPath(modulesDir) {\n  if (Cache.LAST_MODULES_PATH !== modulesDir) {\n    Cache.LAST_MODULES_PATH = modulesDir\n    process.env.NODE_PATH = modulesDir || ''\n    // eslint-disable-next-line no-underscore-dangle\n    require('module').Module._initPaths()\n  }\n}\n\n/**\n * @param {string} fileDir\n * @param {object} config\n * @param {string} projectPath\n * @returns {import(\"eslint\")}\n */\nexport function getESLintInstance(fileDir, config, projectPath) {\n  const modulesDir = Path.dirname(findCached(fileDir, 'node_modules/eslint') || '')\n  refreshModulesPath(modulesDir)\n  return getESLintFromDirectory(modulesDir, config, projectPath)\n}\n\n/**\n * console.log\n * @param  {any} args\n * @return {void}\n */\nexport function log(...args) {\n  const obj = args.length === 1 ? args[0] : args\n  let str\n  try {\n    str = JSON.stringify(obj)\n  } catch (e) {\n    str = Util.inspect(obj)\n  }\n\n  emit('log', str)\n}\n\n/**\n * @param {import(\"eslint\")} eslint\n * @param {string} filePath\n */\nexport function getConfigForFile(eslint, filePath) {\n  const cli = new eslint.CLIEngine()\n  try {\n    return cli.getConfigForFile(filePath)\n  } catch (e) {\n    // No configuration was found\n    return null\n  }\n}\n\n/**\n * @param {string} fileDir\n * @param {string} filePath\n * @param {object} config\n * @param {string} projectPath\n * @returns {string}\n */\nexport function getRelativePath(fileDir, filePath, config, projectPath) {\n  const ignoreFile = config.advanced.disableEslintIgnore ? null : findCached(fileDir, '.eslintignore')\n\n  // If we can find an .eslintignore file, we can set cwd there\n  // (because they are expected to be at the project root)\n  if (ignoreFile) {\n    const ignoreDir = Path.dirname(ignoreFile)\n    process.chdir(ignoreDir)\n    return Path.relative(ignoreDir, filePath)\n  }\n  // Otherwise, we'll set the cwd to the atom project root as long as that exists\n  if (projectPath) {\n    process.chdir(projectPath)\n    return Path.relative(projectPath, filePath)\n  }\n  // If all else fails, use the file location itself\n  process.chdir(fileDir)\n  return Path.basename(filePath)\n}\n\n/**\n * @param {string} type\n * @param {string[]} rules\n * @param {object} config\n * @param {string} filePath\n * @param {object} fileConfig\n */\nexport function getCLIEngineOptions(type, config, rules, filePath, fileConfig) {\n  const cliEngineConfig = {\n    rules,\n    ignore: !config.advanced.disableEslintIgnore,\n    fix: type === 'fix'\n  }\n\n  cliEngineConfig.rulePaths = config.advanced.eslintRulesDirs.map((path) => {\n    const rulesDir = cleanPath(path)\n    if (!Path.isAbsolute(rulesDir)) {\n      return findCached(Path.dirname(filePath), rulesDir)\n    }\n    return rulesDir\n  }).filter((path) => path)\n\n  if (fileConfig === null && config.global.eslintrcPath) {\n    // If we didn't find a configuration use the fallback from the settings\n    cliEngineConfig.configFile = cleanPath(config.global.eslintrcPath)\n  }\n\n  return cliEngineConfig\n}\n\n/**\n * Gets the list of rules used for a lint job\n * @param  {import(\"eslint\").CLIEngine} cliEngine The CLIEngine instance used for the lint job\n * @return {Map}              A Map of the rules used, rule names as keys, rule\n *                            properties as the contents.\n */\nexport function getRules(cliEngine) {\n  // Pull the list of rules used directly from the CLIEngine\n  if (typeof cliEngine.getRules === 'function') {\n    return cliEngine.getRules()\n  }\n\n  // Attempt to use the internal (undocumented) `linter` instance attached to\n  // the CLIEngine to get the loaded rules (including plugin rules).\n  // Added in ESLint v4\n  if (Object.prototype.hasOwnProperty.call(cliEngine, 'linter')) {\n    return cliEngine.linter.getRules()\n  }\n\n  // Older versions of ESLint don't (easily) support getting a list of rules\n  return new Map()\n}\n\n/**\n * Given an exiting rule list and a new rule list, determines whether there\n * have been changes.\n * NOTE: This only accounts for presence of the rules, changes to their metadata\n * are not taken into account.\n * @param  {Map} newRules     A Map of the new rules\n * @param  {Map} currentRules A Map of the current rules\n * @return {boolean}             Whether or not there were changes\n */\nexport function didRulesChange(currentRules, newRules) {\n  return !(currentRules.size === newRules.size\n    && Array.from(currentRules.keys()).every((ruleId) => newRules.has(ruleId)))\n}\n"]} \ No newline at end of file diff --git a/package.json b/package.json index 0a4f8c9c..0c391f19 100644 --- a/package.json +++ b/package.json @@ -2,7 +2,7 @@ "name": "linter-eslint", "main": "./dist/main.js", "version": "9.0.0", - "description": "Lint JavaScript on the fly, using ESLint", + "description": "Lint JavaScript on the fly, using ESLint (v7 or older)", "repository": "https://github.com/AtomLinter/linter-eslint.git", "license": "MIT", "engines": { @@ -155,6 +155,13 @@ "type": "string", "default": "", "order": 5 + }, + "showIncompatibleVersionNotification": { + "title": "Notify when incompatible ESLint is detected", + "description": "When enabled, will show a notification if this package loads inside a project using ESLint version 8 or greater _and_ the user has not already installed the newer `linter-eslint-node` package. Uncheck if you don't want these notifications.", + "type": "boolean", + "default": true, + "order": 6 } } } diff --git a/spec/fixtures/global-eslint/lib/node_modules/eslint/lib/api.js b/spec/fixtures/global-eslint/lib/node_modules/eslint/lib/api.js index 620463e4..3e6df747 100644 --- a/spec/fixtures/global-eslint/lib/node_modules/eslint/lib/api.js +++ b/spec/fixtures/global-eslint/lib/node_modules/eslint/lib/api.js @@ -1 +1 @@ -module.exports = "located" +module.exports = { CLIEngine: true, type: "located" } diff --git a/spec/fixtures/incompatible-eslint/node_modules/eslint/lib/api.js b/spec/fixtures/incompatible-eslint/node_modules/eslint/lib/api.js new file mode 100644 index 00000000..2b374656 --- /dev/null +++ b/spec/fixtures/incompatible-eslint/node_modules/eslint/lib/api.js @@ -0,0 +1 @@ +module.exports = { ESLint: true, type: 'incompatible' } diff --git a/spec/fixtures/incompatible-eslint/node_modules/eslint/package.json b/spec/fixtures/incompatible-eslint/node_modules/eslint/package.json new file mode 100644 index 00000000..01c9f959 --- /dev/null +++ b/spec/fixtures/incompatible-eslint/node_modules/eslint/package.json @@ -0,0 +1 @@ +{ "version": "8.0.0" } diff --git a/spec/fixtures/indirect-local-eslint/testing/eslint/node_modules/eslint/lib/api.js b/spec/fixtures/indirect-local-eslint/testing/eslint/node_modules/eslint/lib/api.js index 620463e4..3e6df747 100644 --- a/spec/fixtures/indirect-local-eslint/testing/eslint/node_modules/eslint/lib/api.js +++ b/spec/fixtures/indirect-local-eslint/testing/eslint/node_modules/eslint/lib/api.js @@ -1 +1 @@ -module.exports = "located" +module.exports = { CLIEngine: true, type: "located" } diff --git a/spec/fixtures/local-eslint/node_modules/eslint/lib/api.js b/spec/fixtures/local-eslint/node_modules/eslint/lib/api.js index 620463e4..3e6df747 100644 --- a/spec/fixtures/local-eslint/node_modules/eslint/lib/api.js +++ b/spec/fixtures/local-eslint/node_modules/eslint/lib/api.js @@ -1 +1 @@ -module.exports = "located" +module.exports = { CLIEngine: true, type: "located" } diff --git a/spec/worker-helpers-spec.js b/spec/worker-helpers-spec.js index 3f829d6d..da5f24cb 100644 --- a/spec/worker-helpers-spec.js +++ b/spec/worker-helpers-spec.js @@ -81,7 +81,7 @@ describe('Worker Helpers', () => { advanced: { localNodeModules: path } }) const eslint = Helpers.getESLintInstance('', config) - expect(eslint).toBe('located') + expect(eslint.type).toBe('located') }) it('tries to find an indirect local eslint using a relative path', () => { @@ -93,13 +93,13 @@ describe('Worker Helpers', () => { }) const eslint = Helpers.getESLintInstance('', config, projectPath) - expect(eslint).toBe('located') + expect(eslint.type).toBe('located') }) it('tries to find a local eslint', () => { const config = createConfig() const eslint = Helpers.getESLintInstance(getFixturesPath('local-eslint'), config) - expect(eslint).toBe('located') + expect(eslint.type).toBe('located') }) it('cries if local eslint is not found', () => { @@ -109,13 +109,20 @@ describe('Worker Helpers', () => { }).toThrow() }) + it('cries if incompatible eslint is found', () => { + expect(() => { + const config = createConfig() + Helpers.getESLintInstance(getFixturesPath('incompatible-eslint'), config) + }).toThrow() + }) + it('tries to find a global eslint if config is specified', () => { const config = createConfig({ global: { useGlobalEslint: true, globalNodePath } }) console.log({ config }) const eslint = Helpers.getESLintInstance(getFixturesPath('local-eslint'), config) - expect(eslint).toBe('located') + expect(eslint.type).toBe('located') }) it('cries if global eslint is not found', () => { @@ -133,7 +140,7 @@ describe('Worker Helpers', () => { const fileDir = Path.join(getFixturesPath('local-eslint'), 'lib', 'foo.js') const config = createConfig() const eslint = Helpers.getESLintInstance(fileDir, config) - expect(eslint).toBe('located') + expect(eslint.type).toBe('located') }) }) diff --git a/src/helpers.js b/src/helpers.js index 98d9e16b..bb24b3c8 100644 --- a/src/helpers.js +++ b/src/helpers.js @@ -4,12 +4,16 @@ import { randomBytes } from 'crypto' import { promisify } from 'util' // eslint-disable-next-line import/no-extraneous-dependencies, import/extensions import { Range, Task } from 'atom' +// eslint-disable-next-line import/no-unresolved +import { shell } from 'electron' import Rules from './rules' import { throwIfInvalidPoint } from './validate/editor' const asyncRandomBytes = promisify(randomBytes) export const rules = new Rules() let worker = null +let isIncompatibleEslintVersion = false +let seenIncompatibleVersionNotification = false /** * Start the worker process if it hasn't already been started @@ -48,6 +52,10 @@ export function killWorker() { } } +export function isIncompatibleEslint() { + return isIncompatibleEslintVersion +} + /** * Send a job to the worker and return the results * @param {Object} config Configuration for the job to send to the worker @@ -74,11 +82,12 @@ export async function sendJob(config) { // All worker errors are caught and re-emitted along with their associated // emitKey, so that we do not create multiple listeners for the same // 'task:error' event - const errSub = worker.on(`workerError:${config.emitKey}`, ({ msg, stack }) => { + const errSub = worker.on(`workerError:${config.emitKey}`, ({ msg, stack, name }) => { // Re-throw errors from the task const error = new Error(msg) // Set the stack to the one given to us by the worker error.stack = stack + error.name = name errSub.dispose() // eslint-disable-next-line no-use-before-define responseSub.dispose() @@ -189,6 +198,44 @@ export function generateUserMessage(textEditor, options) { }] } +function isNewPackageInstalled() { + return atom.packages.isPackageLoaded('linter-eslint-node') + || atom.packages.isPackageDisabled('linter-eslint-node') +} + +function showIncompatibleVersionNotification(message) { + const notificationEnabled = atom.config.get('linter-eslint.advanced.showIncompatibleVersionNotification') + if (!notificationEnabled || seenIncompatibleVersionNotification || isNewPackageInstalled()) { + return + } + + // Show this message only once per session. + seenIncompatibleVersionNotification = true + const notification = atom.notifications.addWarning( + 'linter-eslint: Incompatible version', + { + description: message, + dismissable: true, + buttons: [ + { + text: 'Install linter-eslint-node', + onDidClick() { + shell.openExternal('https://atom.io/packages/linter-eslint-node') + notification.dismiss() + } + }, + { + text: 'Don\'t show this notification again', + onDidClick() { + atom.config.set('linter-eslint.advanced.showIncompatibleVersionNotification', false) + notification.dismiss() + } + } + ] + } + ) +} + /** * Generates a message to the user in order to nicely display the Error being * thrown instead of depending on generic error handling. @@ -197,10 +244,19 @@ export function generateUserMessage(textEditor, options) { * @return {import("atom/linter").Message[]} Message to user generated from the Error */ export function handleError(textEditor, error) { - const { stack, message } = error + const { stack, message, name } = error + // We want this specific worker error to show up as a notification so that we + // can include a button for installing the new package. + if (name === 'IncompatibleESLintError') { + isIncompatibleEslintVersion = true + killWorker() + showIncompatibleVersionNotification(message) + return + } // Only show the first line of the message as the excerpt const excerpt = `Error while running ESLint: ${message.split('\n')[0]}.` const description = `
${message}\n
${stack}
` + // eslint-disable-next-line consistent-return return generateUserMessage(textEditor, { severity: 'error', excerpt, description }) } diff --git a/src/main.js b/src/main.js index 6b5ecfad..d94f3a9c 100644 --- a/src/main.js +++ b/src/main.js @@ -182,6 +182,13 @@ module.exports = { return null } + if (helpers.isIncompatibleEslint()) { + // The project's version of ESLint doesn't work with this package. Once + // this is detected, we won't try to send any jobs until the window is + // reloaded. + return null + } + const filePath = textEditor.getPath() if (!filePath) { // The editor currently has no path, we can't report messages back to @@ -246,6 +253,13 @@ module.exports = { return } + if (helpers.isIncompatibleEslint()) { + // The project's version of ESLint doesn't work with this package. Once + // this is detected, we won't try to send any jobs until the window is + // reloaded. + return + } + if (textEditor.isModified()) { // Abort for invalid or unsaved text editors const message = 'Linter-ESLint: Please save before fixing' @@ -280,6 +294,9 @@ module.exports = { atom.notifications.addSuccess(response) } } catch (err) { + if (err.name === 'IncompatibleESLintError') { + return + } atom.notifications.addWarning(err.message) } }, diff --git a/src/worker-helpers.js b/src/worker-helpers.js index a042ceaf..7375738a 100644 --- a/src/worker-helpers.js +++ b/src/worker-helpers.js @@ -14,6 +14,14 @@ const Cache = { LAST_MODULES_PATH: null } +class IncompatibleESLintError extends Error { + constructor(version) { + // eslint-disable-next-line max-len + super(`The version of ESLint used in this project is ${version}, which is incompatible with this package. The \`linter-eslint-node\` Atom package provides support for ESLint versions 8 and higher.\n\nYou can disable this notice in the linter-eslint package settings under **Uncommon → Notify when incompatible ESLint is detected**.`) + this.name = 'IncompatibleESLintError' + } +} + /** * Takes a path and translates `~` to the user's home directory, and replaces * all environment variables with their value. @@ -112,6 +120,27 @@ export function findESLintDirectory(modulesDir, config, projectPath, fallbackFor } } +// Given an ESLint module path, checks its version and throws if the version is +// too new for this package to support. +function checkForIncompatibleESLint(directory) { + let packageMeta + try { + // eslint-disable-next-line import/no-dynamic-require + packageMeta = require(Path.join(directory, 'package.json')) + if (!packageMeta || !packageMeta.version) { + return + } + } catch (_) { + return + } + // We don't need sophisticated parsing logic here; we just need to look at + // the major version. + const m = packageMeta.version.match(/^([\d]+)\./) + if (m && Number(m[1]) > 7) { + throw new IncompatibleESLintError(packageMeta.version) + } +} + /** * @param {string} modulesDir * @param {object} config @@ -120,10 +149,19 @@ export function findESLintDirectory(modulesDir, config, projectPath, fallbackFor */ export function getESLintFromDirectory(modulesDir, config, projectPath) { const { path: ESLintDirectory } = findESLintDirectory(modulesDir, config, projectPath) + let eslint try { // eslint-disable-next-line import/no-dynamic-require - return require(ESLintDirectory) + eslint = require(ESLintDirectory) + if (!('CLIEngine' in eslint)) { + checkForIncompatibleESLint(ESLintDirectory) + } + return eslint } catch (e) { + // If this is the result of an incompatible ESLint, an error will be + // thrown; otherwise we should proceed with the local-path fallback. + checkForIncompatibleESLint(ESLintDirectory) + if (config.global.useGlobalEslint && e.code === 'MODULE_NOT_FOUND') { throw new Error('ESLint not found, try restarting Atom to clear caches.') } diff --git a/src/worker.js b/src/worker.js index 1be054b8..e68aac80 100644 --- a/src/worker.js +++ b/src/worker.js @@ -99,7 +99,11 @@ module.exports = async () => { } emit(emitKey, response) } catch (workerErr) { - emit(`workerError:${emitKey}`, { msg: workerErr.message, stack: workerErr.stack }) + emit(`workerError:${emitKey}`, { + msg: workerErr.message, + stack: workerErr.stack, + name: workerErr.name + }) } }) }