@platformos/platformos-language-server-common 0.0.2

package/src/codeActions/providers/FixProvider.spec.ts

@@ -0,0 +1,330 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { URI } from 'vscode-uri';
+import { Offense, SourceCodeType, Severity, path } from '@platformos/platformos-check-common';
+import { DiagnosticsManager } from '../../diagnostics';
+import { DocumentManager } from '../../documents';
+import { FixProvider } from './FixProvider';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+
+describe('Unit: FixProvider', () => {
+  const uri = path.normalize(URI.file('/path/to/file.liquid'));
+  const contents = `
+    {% assign x = 1 %}
+    <script src="2.js"></script>
+    <script src="3.js"></script>
+  `;
+  const document = TextDocument.create(uri, 'liquid', 0, contents);
+  let documentManager: DocumentManager;
+  let diagnosticsManager: DiagnosticsManager;
+  let fixProvider: FixProvider;
+
+  function makeOffense(
+    checkName: string,
+    needle: string,
+    unfixable?: boolean,
+  ): Offense<SourceCodeType.LiquidHtml> {
+    const start = contents.indexOf(needle);
+    const end = start + needle.length;
+
+    return {
+      type: SourceCodeType.LiquidHtml,
+      check: checkName,
+      message: 'Parser blocking script detected',
+      uri: 'file:///path/to/file.liquid',
+      severity: Severity.ERROR,
+      start: { ...document.positionAt(start), index: start },
+      end: { ...document.positionAt(end), index: end },
+      fix: unfixable ? undefined : (corrector) => corrector.replace(18, 36, 'fixed'),
+    };
+  }
+
+  beforeEach(() => {
+    documentManager = new DocumentManager();
+    diagnosticsManager = new DiagnosticsManager({ sendDiagnostics: vi.fn() } as any);
+    documentManager.open(uri, contents, 1);
+    fixProvider = new FixProvider(documentManager, diagnosticsManager);
+  });
+
+  describe('When multiple offenses of various types exist, and the selection includes an offense with at least one more of the same type in the file', () => {
+    beforeEach(() => {
+      diagnosticsManager.set(uri, 1, [
+        makeOffense('UnusedAssign', '{% assign x = 1 %}'),
+        makeOffense('ParserBlockingScript', '<script src="2.js"></script>'),
+        makeOffense('ParserBlockingScript', '<script src="3.js"></script>'),
+      ]);
+    });
+
+    it('provides all code actions categories', async () => {
+      const codeActions = fixProvider.codeActions({
+        textDocument: { uri },
+        range: {
+          start: document.positionAt(contents.indexOf('2.js')),
+          end: document.positionAt(contents.indexOf('2.js')),
+        },
+        context: { diagnostics: [] },
+      });
+
+      expect(codeActions.length).toBe(3);
+
+      const [fixCursorAction, fixSameTypeAction, fixAllAction] = codeActions;
+
+      expect(fixCursorAction).toEqual({
+        title: 'Fix this ParserBlockingScript problem: Parser blocking script detected',
+        kind: 'quickfix',
+        diagnostics: expect.any(Array),
+        isPreferred: true,
+        command: {
+          title: 'applyFixes',
+          command: 'themeCheck/applyFixes',
+          arguments: [uri, 1, [1]],
+        },
+      });
+
+      expect(fixSameTypeAction).toEqual({
+        title: 'Fix all ParserBlockingScript problems',
+        kind: 'quickfix',
+        diagnostics: expect.any(Array),
+        isPreferred: false,
+        command: {
+          title: 'applyFixes',
+          command: 'themeCheck/applyFixes',
+          arguments: [uri, 1, [1, 2]],
+        },
+      });
+
+      expect(fixAllAction).toEqual({
+        title: 'Fix all auto-fixable problems',
+        kind: 'quickfix',
+        diagnostics: expect.any(Array),
+        isPreferred: false,
+        command: {
+          title: 'applyFixes',
+          command: 'themeCheck/applyFixes',
+          arguments: [uri, 1, [0, 1, 2]],
+        },
+      });
+    });
+  });
+
+  describe('When multiple offenses of various types exist, and the selection includes an offense without more of the same type in the file', () => {
+    beforeEach(() => {
+      diagnosticsManager.set(uri, 1, [
+        makeOffense('UnusedAssign', '{% assign x = 1 %}'),
+        makeOffense('ParserBlockingScript', '<script src="2.js"></script>'),
+      ]);
+    });
+
+    it('provides code actions, and the fix all same type is omitted', async () => {
+      const codeActions = fixProvider.codeActions({
+        textDocument: { uri },
+        range: {
+          start: document.positionAt(contents.indexOf('2.js')),
+          end: document.positionAt(contents.indexOf('2.js')),
+        },
+        context: { diagnostics: [] },
+      });
+
+      expect(codeActions.length).toBe(2);
+
+      const [fixCursorAction, fixAllAction] = codeActions;
+
+      expect(fixCursorAction).toEqual({
+        title: 'Fix this ParserBlockingScript problem: Parser blocking script detected',
+        kind: 'quickfix',
+        diagnostics: expect.any(Array),
+        isPreferred: true,
+        command: {
+          title: 'applyFixes',
+          command: 'themeCheck/applyFixes',
+          arguments: [uri, 1, [1]],
+        },
+      });
+
+      expect(fixAllAction).toEqual({
+        title: 'Fix all auto-fixable problems',
+        kind: 'quickfix',
+        diagnostics: expect.any(Array),
+        isPreferred: false,
+        command: {
+          title: 'applyFixes',
+          command: 'themeCheck/applyFixes',
+          arguments: [uri, 1, [0, 1]],
+        },
+      });
+    });
+  });
+
+  describe('When only one offense type exists, and the selection includes an offense', () => {
+    beforeEach(() => {
+      diagnosticsManager.set(uri, 1, [
+        makeOffense('ParserBlockingScript', '<script src="2.js"></script>'),
+        makeOffense('ParserBlockingScript', '<script src="3.js"></script>'),
+      ]);
+    });
+
+    it('provides code actions, and the fix all code action is omitted', async () => {
+      const codeActions = fixProvider.codeActions({
+        textDocument: { uri },
+        range: {
+          start: document.positionAt(contents.indexOf('2.js')),
+          end: document.positionAt(contents.indexOf('2.js')),
+        },
+        context: { diagnostics: [] },
+      });
+
+      expect(codeActions.length).toBe(2);
+
+      const [fixCursorAction, fixSameTypeAction] = codeActions;
+
+      expect(fixCursorAction).toEqual({
+        title: 'Fix this ParserBlockingScript problem: Parser blocking script detected',
+        kind: 'quickfix',
+        diagnostics: expect.any(Array),
+        isPreferred: true,
+        command: {
+          title: 'applyFixes',
+          command: 'themeCheck/applyFixes',
+          arguments: [uri, 1, [0]],
+        },
+      });
+
+      expect(fixSameTypeAction).toEqual({
+        title: 'Fix all ParserBlockingScript problems',
+        kind: 'quickfix',
+        diagnostics: expect.any(Array),
+        isPreferred: false,
+        command: {
+          title: 'applyFixes',
+          command: 'themeCheck/applyFixes',
+          arguments: [uri, 1, [0, 1]],
+        },
+      });
+    });
+  });
+
+  describe('When there is only one offense', () => {
+    beforeEach(() => {
+      diagnosticsManager.set(uri, 1, [
+        makeOffense('ParserBlockingScript', '<script src="2.js"></script>'),
+      ]);
+    });
+
+    it('provides a code action to fix it', async () => {
+      const codeActions = fixProvider.codeActions({
+        textDocument: { uri },
+        range: {
+          start: document.positionAt(contents.indexOf('2.js')),
+          end: document.positionAt(contents.indexOf('2.js')),
+        },
+        context: { diagnostics: [] },
+      });
+
+      expect(codeActions.length).toBe(1);
+
+      const [fixCursorAction] = codeActions;
+
+      expect(fixCursorAction).toEqual({
+        title: 'Fix this ParserBlockingScript problem: Parser blocking script detected',
+        kind: 'quickfix',
+        diagnostics: expect.any(Array),
+        isPreferred: true,
+        command: {
+          title: 'applyFixes',
+          command: 'themeCheck/applyFixes',
+          arguments: [uri, 1, [0]],
+        },
+      });
+    });
+  });
+
+  it('provides code actions for a set of fixable offenses', async () => {
+    diagnosticsManager.set(uri, 1, [
+      makeOffense('UnusedAssign', '{% assign x = 1 %}'),
+      makeOffense('ParserBlockingScript', '<script src="2.js"></script>'),
+      makeOffense('ParserBlockingScript', '<script src="3.js"></script>'),
+    ]);
+
+    const codeActions = fixProvider.codeActions({
+      textDocument: { uri },
+      range: {
+        start: document.positionAt(contents.indexOf('2.js')),
+        end: document.positionAt(contents.indexOf('2.js')),
+      },
+      context: { diagnostics: [] },
+    });
+
+    expect(codeActions.length).toBe(3);
+
+    const [fixCursorAction, fixSameTypeAction, fixAllAction] = codeActions;
+
+    expect(fixCursorAction).toEqual({
+      title: 'Fix this ParserBlockingScript problem: Parser blocking script detected',
+      kind: 'quickfix',
+      diagnostics: expect.any(Array),
+      isPreferred: true,
+      command: {
+        title: 'applyFixes',
+        command: 'themeCheck/applyFixes',
+        arguments: [uri, 1, [1]],
+      },
+    });
+
+    expect(fixSameTypeAction).toEqual({
+      title: 'Fix all ParserBlockingScript problems',
+      kind: 'quickfix',
+      diagnostics: expect.any(Array),
+      isPreferred: false,
+      command: {
+        title: 'applyFixes',
+        command: 'themeCheck/applyFixes',
+        arguments: [uri, 1, [1, 2]],
+      },
+    });
+
+    expect(fixAllAction).toEqual({
+      title: 'Fix all auto-fixable problems',
+      kind: 'quickfix',
+      diagnostics: expect.any(Array),
+      isPreferred: false,
+      command: {
+        title: 'applyFixes',
+        command: 'themeCheck/applyFixes',
+        arguments: [uri, 1, [0, 1, 2]],
+      },
+    });
+  });
+
+  it('does not provide code actions for non-fixable offenses', async () => {
+    const nonFixableOffense = makeOffense('ParserBlockingScript', '<script src="2.js">', true);
+    diagnosticsManager.set(uri, 1, [nonFixableOffense]);
+
+    const codeActions = fixProvider.codeActions({
+      textDocument: { uri },
+      range: {
+        start: document.positionAt(contents.indexOf('2.js')),
+        end: document.positionAt(contents.indexOf('2.js')),
+      },
+      context: { diagnostics: [] },
+    });
+
+    expect(codeActions.length).toBe(0);
+  });
+
+  it('does not provide code actions if selection range does not overlap with the error', async () => {
+    diagnosticsManager.set(uri, 1, [
+      makeOffense('ParserBlockingScript', '<script src="2.js"></script>'),
+      makeOffense('ParserBlockingScript', '<script src="3.js"></script>'),
+    ]);
+
+    const codeActions = fixProvider.codeActions({
+      textDocument: { uri },
+      range: {
+        start: document.positionAt(contents.indexOf('assign x = 1')),
+        end: document.positionAt(contents.indexOf('= 1')),
+      },
+      context: { diagnostics: [] },
+    });
+
+    expect(codeActions.length).toBe(0);
+  });
+});

package/src/codeActions/providers/FixProvider.ts

@@ -0,0 +1,105 @@
+import { CodeAction, CodeActionKind, CodeActionParams, Command } from 'vscode-languageserver';
+import { applyFixCommand } from '../../commands';
+import { BaseCodeActionsProvider } from '../BaseCodeActionsProvider';
+import { FixableAnomaly, isFixable, isInRange, toCodeAction } from './utils';
+
+export class FixProvider extends BaseCodeActionsProvider {
+  static kind = CodeActionKind.QuickFix;
+
+  codeActions(params: CodeActionParams): (Command | CodeAction)[] {
+    const { uri } = params.textDocument;
+    const document = this.documentManager.get(uri);
+    const diagnostics = this.diagnosticsManager.get(uri);
+    if (!document || !diagnostics) return [];
+
+    const { textDocument } = document;
+    const { anomalies, version } = diagnostics;
+    const start = textDocument.offsetAt(params.range.start);
+    const end = textDocument.offsetAt(params.range.end);
+
+    const fixableAnomalies = anomalies.filter(isFixable);
+    const anomaliesUnderCursor = fixableAnomalies.filter((anomaly) =>
+      isInRange(anomaly, start, end),
+    );
+    if (anomaliesUnderCursor.length === 0) return [];
+
+    return [
+      ...quickfixCursorActions(uri, version, anomaliesUnderCursor),
+      ...quickfixSameTypeActions(uri, version, anomaliesUnderCursor, fixableAnomalies),
+      ...quickfixAllAction(uri, version, fixableAnomalies),
+    ];
+  }
+}
+
+/**
+ * @returns code actions to fix only one of the offenses under the cursor
+ * @example Fix this ParserBlockingScript problem: '...'
+ */
+function quickfixCursorActions(
+  uri: string,
+  version: number | undefined,
+  anomaliesUnderCursor: FixableAnomaly[],
+): CodeAction[] {
+  return anomaliesUnderCursor.map(({ offense, diagnostic, id }) => {
+    return toCodeAction(
+      `Fix this ${offense.check} problem: ${offense.message}`,
+      applyFixCommand(uri, version, [id]),
+      [diagnostic],
+      FixProvider.kind,
+      true,
+    );
+  });
+}
+
+/**
+ * @returns code actions to fix all offenses of a particular type
+ * @example Fix all ParserBlockingScript problems
+ */
+function quickfixSameTypeActions(
+  uri: string,
+  version: number | undefined,
+  anomaliesUnderCursor: FixableAnomaly[],
+  fixableAnomalies: FixableAnomaly[],
+): CodeAction[] {
+  const checks = new Set(anomaliesUnderCursor.map((anomaly) => anomaly.offense.check));
+  return Array.from(checks).flatMap((check) => {
+    const checkAnomalies = fixableAnomalies.filter(({ offense }) => offense.check === check);
+
+    // We don't want to show this one if there's only one of this type.
+    if (checkAnomalies.length < 2) return [];
+    const ids = checkAnomalies.map((a) => a.id);
+    const diagnostics = checkAnomalies.map((a) => a.diagnostic);
+    return toCodeAction(
+      `Fix all ${check} problems`,
+      applyFixCommand(uri, version, ids),
+      diagnostics,
+      FixProvider.kind,
+    );
+  });
+}
+
+/**
+ * @returns code action to fix all offenses of a particular type
+ * @example Fix all auto-fixable problems
+ */
+function quickfixAllAction(
+  uri: string,
+  version: number | undefined,
+  fixableAnomalies: FixableAnomaly[],
+): CodeAction[] {
+  const ids = fixableAnomalies.map((a) => a.id);
+  const diagnostics = fixableAnomalies.map((a) => a.diagnostic);
+  const checks = new Set(diagnostics.map((a) => a.code));
+
+  // We don't want to this one if there's only one type of problems
+  if (checks.size < 2) return [];
+
+  return [
+    toCodeAction(
+      `Fix all auto-fixable problems`,
+      applyFixCommand(uri, version, ids),
+      diagnostics,
+      FixProvider.kind,
+    ),
+  ];
+}

package/src/codeActions/providers/SuggestionProvider.spec.ts

@@ -0,0 +1,143 @@
+import {
+  Offense,
+  Severity,
+  SourceCodeType,
+  Suggestion,
+  path,
+} from '@platformos/platformos-check-common';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { URI } from 'vscode-uri';
+import { DiagnosticsManager } from '../../diagnostics';
+import { DocumentManager } from '../../documents';
+import { SuggestionProvider } from './SuggestionProvider';
+
+describe('Unit: SuggestionProvider', () => {
+  const uri = path.normalize(URI.file('/path/to/file.liquid'));
+  const contents = `
+    {% assign x = 1 %}
+    <script src="2.js"></script>
+    <script src="3.js"></script>
+  `;
+  const version = 0;
+  const document = TextDocument.create(uri, 'liquid', version, contents);
+  let documentManager: DocumentManager;
+  let diagnosticsManager: DiagnosticsManager;
+  let suggestionProvider: SuggestionProvider;
+
+  function makeOffense(
+    checkName: string,
+    needle: string,
+    unfixable?: boolean,
+  ): Offense<SourceCodeType.LiquidHtml> {
+    const start = contents.indexOf(needle);
+    const end = start + needle.length;
+    const suggestion = (replaceWith: string): Suggestion<SourceCodeType.LiquidHtml> => ({
+      message: `Replace with ${replaceWith}`,
+      fix: (corrector) => corrector.replace(start, end, replaceWith),
+    });
+
+    return {
+      type: SourceCodeType.LiquidHtml,
+      check: checkName,
+      message: 'Parser blocking script detected',
+      uri: 'file:///path/to/file.liquid',
+      severity: Severity.ERROR,
+      start: { ...document.positionAt(start), index: start },
+      end: { ...document.positionAt(end), index: end },
+      suggest: unfixable ? undefined : [suggestion('defer'), suggestion('async')],
+    };
+  }
+
+  beforeEach(() => {
+    documentManager = new DocumentManager();
+    diagnosticsManager = new DiagnosticsManager({ sendDiagnostics: vi.fn() } as any);
+    documentManager.open(uri, contents, version);
+    suggestionProvider = new SuggestionProvider(documentManager, diagnosticsManager);
+  });
+
+  describe('When multiple offenses of various types exist, and the selection includes an offense with at least one more of the same type in the file', () => {
+    it('provides all code actions categories', async () => {
+      const offenses = [
+        makeOffense('UnusedAssign', '{% assign x = 1 %}'),
+        makeOffense('ParserBlockingScript', '<script src="2.js"></script>'),
+        makeOffense('ParserBlockingScript', '<script src="3.js"></script>'),
+      ];
+
+      diagnosticsManager.set(uri, version, offenses);
+
+      const codeActions = suggestionProvider.codeActions({
+        textDocument: { uri },
+        range: {
+          start: document.positionAt(contents.indexOf('2.js')),
+          end: document.positionAt(contents.indexOf('2.js')),
+        },
+        context: { diagnostics: [] },
+      });
+
+      expect(codeActions.length).toBe(2);
+
+      // We're targetting <script src=2.js> (index = 1 in the offense array)
+      const anomalyId = 1;
+      const [deferSuggestion, asyncSuggestion] = codeActions;
+
+      expect(deferSuggestion).toEqual({
+        title: `Suggestion: Replace with defer`,
+        kind: 'quickfix',
+        diagnostics: expect.any(Array),
+        isPreferred: false,
+        command: {
+          title: 'applySuggestion',
+          command: 'themeCheck/applySuggestion',
+          arguments: [uri, version, anomalyId, 0],
+        },
+      });
+
+      expect(asyncSuggestion).toEqual({
+        title: `Suggestion: Replace with async`,
+        kind: 'quickfix',
+        diagnostics: expect.any(Array),
+        isPreferred: false,
+        command: {
+          title: 'applySuggestion',
+          command: 'themeCheck/applySuggestion',
+          arguments: [uri, version, anomalyId, 1],
+        },
+      });
+    });
+  });
+
+  it('does not provide code actions for offenses with no suggestions', async () => {
+    const nonFixableOffense = makeOffense('ParserBlockingScript', '<script src="2.js">', true);
+    diagnosticsManager.set(uri, version, [nonFixableOffense]);
+
+    const codeActions = suggestionProvider.codeActions({
+      textDocument: { uri },
+      range: {
+        start: document.positionAt(contents.indexOf('2.js')),
+        end: document.positionAt(contents.indexOf('2.js')),
+      },
+      context: { diagnostics: [] },
+    });
+
+    expect(codeActions.length).toBe(0);
+  });
+
+  it('does not provide code actions if selection range does not overlap with the error', async () => {
+    diagnosticsManager.set(uri, version, [
+      makeOffense('ParserBlockingScript', '<script src="2.js"></script>'),
+      makeOffense('ParserBlockingScript', '<script src="3.js"></script>'),
+    ]);
+
+    const codeActions = suggestionProvider.codeActions({
+      textDocument: { uri },
+      range: {
+        start: document.positionAt(contents.indexOf('assign x = 1')),
+        end: document.positionAt(contents.indexOf('= 1')),
+      },
+      context: { diagnostics: [] },
+    });
+
+    expect(codeActions.length).toBe(0);
+  });
+});

package/src/codeActions/providers/SuggestionProvider.ts

@@ -0,0 +1,75 @@
+import { Offense, SourceCodeType, WithRequired } from '@platformos/platformos-check-common';
+import {
+  CodeAction,
+  CodeActionKind,
+  CodeActionParams,
+  Command,
+  Diagnostic,
+} from 'vscode-languageserver';
+import { applySuggestionCommand } from '../../commands/providers';
+import { Anomaly } from '../../diagnostics';
+import { BaseCodeActionsProvider } from '../BaseCodeActionsProvider';
+import { isInRange, toCodeAction } from './utils';
+
+export class SuggestionProvider extends BaseCodeActionsProvider {
+  static kind = CodeActionKind.QuickFix;
+
+  codeActions(params: CodeActionParams): (Command | CodeAction)[] {
+    const { uri } = params.textDocument;
+    const document = this.documentManager.get(uri);
+    const diagnostics = this.diagnosticsManager.get(uri);
+    if (!document || !diagnostics) return [];
+
+    const { textDocument } = document;
+    const { anomalies, version } = diagnostics;
+    const start = textDocument.offsetAt(params.range.start);
+    const end = textDocument.offsetAt(params.range.end);
+
+    const suggestibleAnomalies = anomalies.filter(isSuggestible);
+    const anomaliesUnderCursor = suggestibleAnomalies.filter((anomaly) =>
+      isInRange(anomaly, start, end),
+    );
+    if (anomaliesUnderCursor.length === 0) return [];
+
+    return quickfixCursorActions(uri, version, anomaliesUnderCursor);
+  }
+}
+
+/**
+ * @returns all Offense.suggest code actions for the offenses under the cursor
+ * @example Suggestion: Add the `defer` HTML attribute
+ */
+function quickfixCursorActions(
+  uri: string,
+  version: number | undefined,
+  anomaliesUnderCursor: SuggestibleAnomaly[],
+): CodeAction[] {
+  return anomaliesUnderCursor.flatMap(({ offense, diagnostic, id }) => {
+    return offense.suggest.map((suggestion, suggestionId) =>
+      toCodeAction(
+        `Suggestion: ${suggestion.message}`,
+        applySuggestionCommand(uri, version, id, suggestionId),
+        [diagnostic],
+        SuggestionProvider.kind,
+      ),
+    );
+  });
+}
+
+/**
+ * An anomaly is suggestible if the offense has the `suggest` attribute
+ *
+ * This type guarantees that Offense.suggest is defined
+ */
+type SuggestibleAnomaly<S extends SourceCodeType = SourceCodeType> = S extends SourceCodeType
+  ? {
+      diagnostic: Diagnostic;
+      offense: WithRequired<Offense<S>, 'suggest'>;
+      id: number;
+    }
+  : never;
+
+function isSuggestible(anomaly: Anomaly): anomaly is SuggestibleAnomaly {
+  const { offense } = anomaly;
+  return 'suggest' in offense && offense.suggest !== undefined;
+}

package/src/codeActions/providers/index.ts

@@ -0,0 +1,3 @@
+export { FixProvider } from './FixProvider';
+export { FixAllProvider } from './FixAllProvider';
+export { SuggestionProvider } from './SuggestionProvider';