eslint-interactive 8.1.0

package/src/plugin/fix-rule.ts

@@ -0,0 +1,142 @@
+import { ESLint, Rule } from 'eslint';
+import {
+  createFixToApplyAutoFixes,
+  createFixToApplySuggestions,
+  createFixToDisablePerFile,
+  createFixToDisablePerLine,
+  createFixToMakeFixableAndFix,
+} from './fix/index.js';
+import { ruleFixer } from './rule-fixer.js';
+import { Fix, FixContext } from './index.js';
+
+export const OVERLAPPED_PROBLEM_MESSAGE = 'overlapped';
+
+// from: https://github.com/eslint/eslint/blob/58840ac844a61c72eabb603ecfb761812b82a7ed/lib/linter/report-translator.js#L136
+function compareFixesByRange(a: Rule.Fix, b: Rule.Fix): number {
+  return a.range[0] - b.range[0] || a.range[1] - b.range[1];
+}
+
+/**
+ * @file The rule to do the fix.
+ * The fix function returns the `Rule.Fix` that describes how to fix the code.
+ * To apply the fix to your code, you need to use ESLint's API to apply the `Rule.Fix`.
+ *
+ * However, there is no dedicated API in ESLint to apply `Rule.Fix` (there is an internal API
+ * called `SourceCodeFixer`,but it is not exposed to the public). For now, the only way
+ * to apply `Rule.Fix` is to report a fixable problem from a rule and fix it
+ * with `ESLint.outputFixes`.
+ *
+ * This module is a rule that executes a fix function and converts the return value
+ * to a fixable problem.
+ */
+
+const fileStatusMap = new Map<string, { isAlreadyFixed: boolean; hasOverlappedProblem: boolean }>();
+
+function createFixes(context: Rule.RuleContext, ruleOption: FixRuleOption, fixer: Rule.RuleFixer): Rule.Fix[] | null {
+  const { fix, results, ruleIds } = ruleOption;
+  const result = results.find((result) => result.filePath === context.getFilename());
+  if (!result) return null;
+  const messages = result.messages.filter((message) => message.ruleId && ruleIds.includes(message.ruleId));
+
+  const fixContext: FixContext = {
+    filename: context.getFilename(),
+    sourceCode: context.getSourceCode(),
+    messages,
+    ruleIds,
+    fixer,
+  };
+
+  let fixes: Rule.Fix[] = [];
+  if (fix.name === 'applyAutoFixes') {
+    fixes = createFixToApplyAutoFixes(fixContext, fix.args);
+  } else if (fix.name === 'disablePerLine') {
+    fixes = createFixToDisablePerLine(fixContext, fix.args);
+  } else if (fix.name === 'disablePerFile') {
+    fixes = createFixToDisablePerFile(fixContext, fix.args);
+  } else if (fix.name === 'applySuggestions') {
+    fixes = createFixToApplySuggestions(fixContext, fix.args);
+  } else if (fix.name === 'makeFixableAndFix') {
+    fixes = createFixToMakeFixableAndFix(fixContext, fix.args);
+  } else {
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions, @typescript-eslint/no-explicit-any
+    throw new Error(`Unknown fix: ${(fix as any).name}`);
+  }
+
+  if (fixes.length === 0) return null;
+  return fixes;
+}
+
+export type FixRuleOption = {
+  ruleIds: string[];
+  results: ESLint.LintResult[];
+  fix: Fix;
+};
+
+export const fixRule: Rule.RuleModule = {
+  meta: {
+    fixable: 'code',
+  },
+  create(context: Rule.RuleContext) {
+    // TODO: refactor
+    return {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      Program: () => {
+        const filename = context.getFilename();
+
+        // 🤯🤯🤯 THIS IS SUPER HACK!!! 🤯🤯🤯
+        // fix するとコードが変わり、また別の lint エラーが発生する可能性があるため、eslint は `context.report` で
+        // 報告されたエラーの fix がすべて終わったら、再び create を呼び出し、また `context.report` で fix 可能なエラーが
+        // 報告されないかを確認する仕様になっている (これは `context.report` で fix 可能なものがなくなるまで続く)。
+        // そのため、ここでは2回目以降 create が呼び出された時に、誤って再び fix してしまわないよう、fix 済み
+        // であれば early return するようにしている。
+        const status = fileStatusMap.get(filename) ?? { isAlreadyFixed: false, hasOverlappedProblem: false };
+        if (status.isAlreadyFixed) {
+          fileStatusMap.delete(filename); // Reset just in case.
+          if (status.hasOverlappedProblem) {
+            context.report({
+              loc: {
+                // The location is required, so set dummy values.
+                line: 0,
+                column: 0,
+              },
+              message: OVERLAPPED_PROBLEM_MESSAGE,
+            });
+          }
+          return;
+        }
+
+        const ruleOption = context.options[0] as FixRuleOption;
+        const newStatus = {
+          isAlreadyFixed: true,
+          hasOverlappedProblem: false,
+        };
+
+        const fixes = createFixes(context, ruleOption, ruleFixer);
+        if (!fixes) return;
+        fixes.sort(compareFixesByRange);
+
+        let lastPos = 0;
+        const fixesToReport: Rule.Fix[] = [];
+        for (const fix of fixes) {
+          if (fix.range[0] < lastPos) {
+            newStatus.hasOverlappedProblem = true;
+            continue;
+          }
+          fixesToReport.push(fix);
+          lastPos = fix.range[1];
+        }
+        fileStatusMap.set(filename, newStatus);
+
+        context.report({
+          loc: {
+            // The location is required, so set dummy values.
+            line: 0,
+            column: 0,
+          },
+          message: `fix`,
+          fix: () => fixesToReport,
+        });
+      },
+    };
+  },
+};

package/src/plugin/index.ts

@@ -0,0 +1,66 @@
+import { Linter, Rule, SourceCode } from 'eslint';
+import { fixRule, type FixRuleOption } from './fix-rule.js';
+import {
+  type FixableMaker,
+  type SuggestionFilter,
+  type FixToApplySuggestionsArgs,
+  type FixToDisablePerFileArgs,
+  type FixToDisablePerLineArgs,
+  type FixToMakeFixableAndFixArgs,
+  type FixToApplyAutoFixesArgs,
+} from './fix/index.js';
+import { preferAdditionShorthandRule } from './prefer-addition-shorthand-rule.js';
+
+export { OVERLAPPED_PROBLEM_MESSAGE } from './fix-rule.js';
+
+export { FixRuleOption, type FixableMaker, type SuggestionFilter };
+
+export const eslintInteractivePlugin = {
+  rules: {
+    'fix': fixRule,
+    // for test
+    'prefer-addition-shorthand': preferAdditionShorthandRule,
+  },
+};
+
+/**
+ * The type representing the fix to do.
+ */
+export type Fix =
+  | { name: 'applyAutoFixes'; args: FixArg<'applyAutoFixes'> }
+  | { name: 'disablePerLine'; args: FixArg<'disablePerLine'> }
+  | { name: 'disablePerFile'; args: FixArg<'disablePerFile'> }
+  | { name: 'applySuggestions'; args: FixArg<'applySuggestions'> }
+  | { name: 'makeFixableAndFix'; args: FixArg<'makeFixableAndFix'> };
+
+/** For test */
+export type FixName = 'applyAutoFixes' | 'disablePerLine' | 'disablePerFile' | 'applySuggestions' | 'makeFixableAndFix';
+
+/** For test */
+export type FixArg<T extends FixName> = T extends 'applyAutoFixes'
+  ? FixToApplyAutoFixesArgs
+  : T extends 'disablePerLine'
+  ? FixToDisablePerLineArgs
+  : T extends 'disablePerFile'
+  ? FixToDisablePerFileArgs
+  : T extends 'applySuggestions'
+  ? FixToApplySuggestionsArgs
+  : T extends 'makeFixableAndFix'
+  ? FixToMakeFixableAndFixArgs
+  : never;
+
+/**
+ * The type representing the additional information for the fix.
+ */
+export type FixContext = {
+  filename: string;
+  sourceCode: SourceCode;
+  messages: Linter.LintMessage[];
+  ruleIds: string[];
+  fixer: Rule.RuleFixer;
+};
+
+/**
+ * The type representing the fix function.
+ */
+export type FixFunction<T> = (context: FixContext, args: T) => Rule.Fix[];

package/src/plugin/prefer-addition-shorthand-rule.ts

@@ -0,0 +1,56 @@
+import { Rule } from 'eslint';
+
+/**
+ * @file This is a rule for testing purposes.
+ */
+
+export type ApplyFixesRuleOption = Rule.Fix[];
+
+export const preferAdditionShorthandRule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    // @ts-ignore
+    hasSuggestions: true,
+  },
+  create(context: Rule.RuleContext) {
+    return {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      AssignmentExpression: (node) => {
+        if (node.left.type !== 'Identifier') return;
+        const leftIdentifier = node.left;
+        if (node.right.type !== 'BinaryExpression') return;
+        const rightBinaryExpression = node.right;
+        if (rightBinaryExpression.operator !== '+') return;
+        if (rightBinaryExpression.left.type !== 'Identifier') return;
+        const rightIdentifier = rightBinaryExpression.left;
+        if (leftIdentifier.name !== rightIdentifier.name) return;
+        if (rightBinaryExpression.right.type !== 'Literal' || rightBinaryExpression.right.value !== 1) return;
+
+        context.report({
+          node,
+          message: 'The addition method is redundant.',
+          suggest: [
+            {
+              desc: 'Use `val += 1` instead.',
+              fix: function (fixer) {
+                return fixer.replaceText(node, `${leftIdentifier.name} += 1`);
+              },
+            },
+            {
+              desc: 'Use `val++` instead.',
+              fix: function (fixer) {
+                return fixer.replaceText(node, `${leftIdentifier.name}++`);
+              },
+            },
+            {
+              desc: 'Use `++val` instead.',
+              fix: function (fixer) {
+                return fixer.replaceText(node, `++${leftIdentifier.name}`);
+              },
+            },
+          ],
+        });
+      },
+    };
+  },
+};

package/src/plugin/rule-fixer.ts

@@ -0,0 +1,147 @@
+// copy from: https://github.com/eslint/eslint/blob/219aecb78bc646d44bad27dc775a9b3d3dc58232/lib/linter/rule-fixer.js
+// ESLint does not export the RuleFixer. So, I've copied the implementation.
+
+/**
+ * @fileoverview An object that creates fix commands for rules.
+ * @author Nicholas C. Zakas
+ */
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+// none!
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+import { AST, Rule } from 'eslint';
+import type { Node } from 'estree';
+
+/**
+ * Creates a fix command that inserts text at the specified index in the source text.
+ * @param {int} index The 0-based index at which to insert the new text.
+ * @param {string} text The text to insert.
+ * @returns {Object} The fix command.
+ * @private
+ */
+function insertTextAt(index: number, text: string): Rule.Fix {
+  return {
+    range: [index, index],
+    text,
+  };
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/**
+ * Creates code fixing commands for rules.
+ */
+
+/** @type {import('eslint').Rule.RuleFixer} */
+const ruleFixer = Object.freeze({
+  /**
+   * Creates a fix command that inserts text after the given node or token.
+   * The fix is not applied until applyFixes() is called.
+   * @param {ASTNode|Token} nodeOrToken The node or token to insert after.
+   * @param {string} text The text to insert.
+   * @returns {Object} The fix command.
+   */
+  insertTextAfter(nodeOrToken: Node | AST.Token, text: string): Rule.Fix {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return this.insertTextAfterRange(nodeOrToken.range!, text);
+  },
+
+  /**
+   * Creates a fix command that inserts text after the specified range in the source text.
+   * The fix is not applied until applyFixes() is called.
+   * @param {int[]} range The range to replace, first item is start of range, second
+   *      is end of range.
+   * @param {string} text The text to insert.
+   * @returns {Object} The fix command.
+   */
+  insertTextAfterRange(range: AST.Range, text: string): Rule.Fix {
+    return insertTextAt(range[1], text);
+  },
+
+  /**
+   * Creates a fix command that inserts text before the given node or token.
+   * The fix is not applied until applyFixes() is called.
+   * @param {ASTNode|Token} nodeOrToken The node or token to insert before.
+   * @param {string} text The text to insert.
+   * @returns {Object} The fix command.
+   */
+  insertTextBefore(nodeOrToken: Node | AST.Token, text: string): Rule.Fix {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return this.insertTextBeforeRange(nodeOrToken.range!, text);
+  },
+
+  /**
+   * Creates a fix command that inserts text before the specified range in the source text.
+   * The fix is not applied until applyFixes() is called.
+   * @param {int[]} range The range to replace, first item is start of range, second
+   *      is end of range.
+   * @param {string} text The text to insert.
+   * @returns {Object} The fix command.
+   */
+  insertTextBeforeRange(range: AST.Range, text: string): Rule.Fix {
+    return insertTextAt(range[0], text);
+  },
+
+  /**
+   * Creates a fix command that replaces text at the node or token.
+   * The fix is not applied until applyFixes() is called.
+   * @param {ASTNode|Token} nodeOrToken The node or token to remove.
+   * @param {string} text The text to insert.
+   * @returns {Object} The fix command.
+   */
+  replaceText(nodeOrToken: Node | AST.Token, text: string): Rule.Fix {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return this.replaceTextRange(nodeOrToken.range!, text);
+  },
+
+  /**
+   * Creates a fix command that replaces text at the specified range in the source text.
+   * The fix is not applied until applyFixes() is called.
+   * @param {int[]} range The range to replace, first item is start of range, second
+   *      is end of range.
+   * @param {string} text The text to insert.
+   * @returns {Object} The fix command.
+   */
+  replaceTextRange(range: AST.Range, text: string): Rule.Fix {
+    return {
+      range,
+      text,
+    };
+  },
+
+  /**
+   * Creates a fix command that removes the node or token from the source.
+   * The fix is not applied until applyFixes() is called.
+   * @param {ASTNode|Token} nodeOrToken The node or token to remove.
+   * @returns {Object} The fix command.
+   */
+  remove(nodeOrToken: Node | AST.Token): Rule.Fix {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return this.removeRange(nodeOrToken.range!);
+  },
+
+  /**
+   * Creates a fix command that removes the specified range of text from the source.
+   * The fix is not applied until applyFixes() is called.
+   * @param {int[]} range The range to remove, first item is start of range, second
+   *      is end of range.
+   * @returns {Object} The fix command.
+   */
+  removeRange(range: AST.Range): Rule.Fix {
+    return {
+      range,
+      text: '',
+    };
+  },
+});
+
+export { ruleFixer };

package/src/scene/check-results.ts

@@ -0,0 +1,43 @@
+import { ESLint } from 'eslint';
+import { undoingSpinner } from '../cli/ora.js';
+import { Action, promptToInputWhatToDoNext } from '../cli/prompt.js';
+import { Undo } from '../core.js';
+import { NextScene } from './index.js';
+
+export type CheckResultsArgs = {
+  /** The lint results of the project */
+  results: ESLint.LintResult[];
+  /** The rule ids that are in the `results`. */
+  ruleIdsInResults: string[];
+  /** The rule ids to perform the action. */
+  selectedRuleIds: string[];
+  /** The function to execute undo. */
+  undo: Undo;
+  /** The selected actions. */
+  selectedAction: Action;
+};
+
+/**
+ * Run the scene where a user check the fix results.
+ */
+export async function checkResults({
+  results,
+  ruleIdsInResults,
+  selectedRuleIds,
+  undo,
+  selectedAction,
+}: CheckResultsArgs): Promise<NextScene> {
+  const nextStep = await promptToInputWhatToDoNext();
+  if (nextStep === 'exit') return { name: 'exit' };
+  if (nextStep === 'undoTheFix') {
+    await undoingSpinner(async () => undo());
+    return {
+      name: 'selectAction',
+      args: { results, ruleIdsInResults, selectedRuleIds, initialAction: selectedAction },
+    };
+  }
+  console.log();
+  console.log('─'.repeat(process.stdout.columns));
+  console.log();
+  return { name: 'lint' };
+}

package/src/scene/index.ts

@@ -0,0 +1,18 @@
+import { CheckResultsArgs } from './check-results.js';
+import { selectAction, type SelectActionArgs } from './select-action.js';
+import { selectRuleIds, type SelectRuleIdsArgs } from './select-rule-ids.js';
+
+export { selectAction, type SelectActionArgs, selectRuleIds, type SelectRuleIdsArgs };
+export { lint } from './lint.js';
+export { checkResults } from './check-results.js';
+
+/**
+ * The return type when calling a scene function.
+ * Indicates which scene to jump to next.
+ */
+export type NextScene =
+  | { name: 'lint' }
+  | { name: 'selectRuleIds'; args: SelectRuleIdsArgs }
+  | { name: 'selectAction'; args: SelectActionArgs }
+  | { name: 'checkResults'; args: CheckResultsArgs }
+  | { name: 'exit' };

package/src/scene/lint.ts

@@ -0,0 +1,41 @@
+import { Remote } from 'comlink';
+import { warn } from '../cli/log.js';
+import { lintingSpinner } from '../cli/ora.js';
+import { SerializableCore } from '../core-worker.js';
+import { unique } from '../util/array.js';
+import { notEmpty } from '../util/type-check.js';
+import { NextScene } from './index.js';
+
+/**
+ * Run the scene to lint.
+ */
+export async function lint(core: Remote<SerializableCore>): Promise<NextScene> {
+  const results = await lintingSpinner(async () => core.lint());
+  console.log();
+
+  const ruleIdsInResults = unique(
+    results
+      .flatMap((result) => result.messages)
+      .flatMap((message) => message.ruleId)
+      .filter(notEmpty),
+  );
+
+  if (ruleIdsInResults.length === 0) {
+    console.log('💚 No error found.');
+    return { name: 'exit' };
+  }
+  console.log(await core.formatResultSummary(results));
+
+  const hasESLintCoreProblems = results.flatMap((result) => result.messages).some((message) => message.ruleId === null);
+  if (hasESLintCoreProblems) {
+    warn(
+      'ESLint Core Problems are found. ' +
+        'The problems cannot be fixed by eslint-interactive. ' +
+        'Check the details of the problem and fix it. ' +
+        'This is usually caused by the invalid eslintrc or the invalid syntax of the linted code.',
+    );
+    console.log(await core.formatResultDetails(results, [null]));
+  }
+  console.log();
+  return { name: 'selectRuleIds', args: { results, ruleIdsInResults } };
+}

package/src/scene/select-action.ts

@@ -0,0 +1,70 @@
+import { Remote } from 'comlink';
+import { ESLint } from 'eslint';
+import {
+  doApplySuggestionsAction,
+  doDisablePerFileAction,
+  doDisablePerLineAction,
+  doFixAction,
+  doMakeFixableAndFixAction,
+  doPrintResultDetailsAction,
+} from '../action/index.js';
+import { Action, promptToInputAction } from '../cli/prompt.js';
+import { SerializableCore } from '../core-worker.js';
+import { Undo } from '../core.js';
+import { unreachable } from '../util/type-check.js';
+import { NextScene } from './index.js';
+
+export type SelectActionArgs = {
+  /** The lint results of the project */
+  results: ESLint.LintResult[];
+  /** The rule ids that are in the `results`. */
+  ruleIdsInResults: string[];
+  /** The rule ids to perform the action. */
+  selectedRuleIds: string[];
+  /** The action to be initially selected. */
+  initialAction?: Action;
+};
+
+/**
+ * Run the scene where a user select the action to be performed for the problems of selected rules.
+ */
+export async function selectAction(
+  core: Remote<SerializableCore>,
+  { results, ruleIdsInResults, selectedRuleIds, initialAction }: SelectActionArgs,
+): Promise<NextScene> {
+  const selectedAction = await promptToInputAction(results, selectedRuleIds, initialAction);
+
+  const selectRuleIdsScene: NextScene = { name: 'selectRuleIds', args: { results, ruleIdsInResults } };
+  const selectActionScene: NextScene = { name: 'selectAction', args: { results, ruleIdsInResults, selectedRuleIds } };
+
+  function createCheckResultsScene(undo: Undo): NextScene {
+    return {
+      name: 'checkResults',
+      args: { results, ruleIdsInResults, selectedRuleIds, undo, selectedAction },
+    };
+  }
+
+  if (selectedAction === 'reselectRules') return selectRuleIdsScene;
+
+  if (selectedAction === 'printResultDetails') {
+    await doPrintResultDetailsAction(core, results, selectedRuleIds);
+    return selectActionScene;
+  } else if (selectedAction === 'applyAutoFixes') {
+    const undo = await doFixAction(core, results, selectedRuleIds);
+    return createCheckResultsScene(undo);
+  } else if (selectedAction === 'disablePerLine') {
+    const undo = await doDisablePerLineAction(core, results, selectedRuleIds);
+    return createCheckResultsScene(undo);
+  } else if (selectedAction === 'disablePerFile') {
+    const undo = await doDisablePerFileAction(core, results, selectedRuleIds);
+    return createCheckResultsScene(undo);
+  } else if (selectedAction === 'applySuggestions') {
+    const undo = await doApplySuggestionsAction(core, results, selectedRuleIds);
+    return createCheckResultsScene(undo);
+  } else if (selectedAction === 'makeFixableAndFix') {
+    const undo = await doMakeFixableAndFixAction(core, results, selectedRuleIds);
+    return createCheckResultsScene(undo);
+  }
+  // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+  return unreachable(`unknown action: ${selectedAction}`);
+}

package/src/scene/select-rule-ids.ts

@@ -0,0 +1,24 @@
+import { Remote } from 'comlink';
+import { ESLint } from 'eslint';
+import { promptToInputRuleIds } from '../cli/prompt.js';
+import { SerializableCore } from '../core-worker.js';
+import { selectAction } from './select-action.js';
+import { NextScene } from './index.js';
+
+export type SelectRuleIdsArgs = {
+  /** The lint results of the project */
+  results: ESLint.LintResult[];
+  /** The rule ids that are in the `results`. */
+  ruleIdsInResults: string[];
+};
+
+/**
+ * Run the scene where a user select rule ids.
+ */
+export async function selectRuleIds(
+  core: Remote<SerializableCore>,
+  { results, ruleIdsInResults }: SelectRuleIdsArgs,
+): Promise<NextScene> {
+  const selectedRuleIds = await promptToInputRuleIds(ruleIdsInResults);
+  return await selectAction(core, { results, ruleIdsInResults, selectedRuleIds });
+}

package/src/typings/cachedir.d.ts

@@ -0,0 +1,5 @@
+declare module 'cachedir' {
+  // eslint-disable-next-line import/no-default-export
+  function cachedir(name: string): string;
+  export = cachedir;
+}

package/src/typings/node-pager.d.ts

@@ -0,0 +1,4 @@
+declare module 'node-pager' {
+  // eslint-disable-next-line import/no-default-export
+  export default function pager(str: string): Promise<void>;
+}

package/src/util/array.ts

@@ -0,0 +1,16 @@
+export function unique<T>(array: T[]): T[] {
+  return [...new Set(array)];
+}
+
+export function groupBy<T, K>(array: T[], toKey: (item: T) => K): Map<K, T[]> {
+  const map = new Map<K, T[]>();
+
+  for (const item of array) {
+    const key = toKey(item);
+    const oldValue = map.get(key);
+    const newValue = oldValue ? [...oldValue, item] : [item];
+    map.set(key, newValue);
+  }
+
+  return map;
+}

package/src/util/cache.ts

@@ -0,0 +1,11 @@
+import { join } from 'path';
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+import cachedir = require('cachedir');
+import { VERSION } from '../cli/package.js';
+
+/**
+ * Get the path of cache directory for eslint-interactive.
+ */
+export function getCacheDir(): string {
+  return join(cachedir('eslint-interactive'), VERSION);
+}