@zentryc5t/ts-plugin-for-bruno 3.0.6 → 3.2.0

package/src/diagnostics/filterDefaultDiagnostics.ts

@@ -0,0 +1,145 @@
+import { extname } from "path";
+import * as ts from "typescript/lib/tsserverlibrary";
+import { getCodeBlockIndizesForBruFile } from "../codeBlocks/bruCodeBlocks";
+import { isInABrunoCollection } from "../collection/collectionFormat";
+import {
+    getNamesForInbuiltRuntimeVarsAndFunctions,
+    getTempJsFileBaseNameWithoutExtension,
+} from "../constants";
+import { getFileContent } from "../fileContent";
+import { isBruFile, isYamlFile } from "../fileTypes";
+
+type AnyDiagnostic = ts.Diagnostic | ts.DiagnosticWithLocation;
+
+export function filterDefaultDiagnostics(
+    info: ts.server.PluginCreateInfo,
+    fileName: string,
+    defaultDiagnostics: AnyDiagnostic[],
+) {
+    if (isYamlFile(fileName)) {
+        return filterDiagnosticsForYamlFile(info, fileName, defaultDiagnostics);
+    } else if (!isBruFile(fileName)) {
+        return extname(fileName) == ".js"
+            ? filterDiagnosticsForJsFile(info, fileName, defaultDiagnostics)
+            : defaultDiagnostics;
+    }
+
+    const fileContent = getFileContent(info, fileName);
+
+    if (!fileContent) {
+        return [];
+    }
+
+    const indizes = getCodeBlockIndizesForBruFile(fileContent);
+
+    if (indizes.length == 0) {
+        return [];
+    }
+
+    return filterOutDiagnosticsForInbuiltRuntimeFunctions(
+        defaultDiagnostics.filter(
+            ({ start }) =>
+                start != undefined &&
+                indizes.some(
+                    ({ startIndex: blockStart, endIndex: blockEnd }) =>
+                        start >= blockStart && start <= blockEnd,
+                ),
+        ),
+        fileContent,
+    );
+}
+
+/**
+ * The Typescript server only sees the code of scripts within Yaml files (see `maskYamlFilesForTypescriptServer`).
+ * Therefore, all diagnostics are already located within code blocks.
+ */
+function filterDiagnosticsForYamlFile(
+    info: ts.server.PluginCreateInfo,
+    fileName: string,
+    defaultDiagnostics: AnyDiagnostic[],
+) {
+    const fileContent = getFileContent(info, fileName);
+
+    return fileContent
+        ? filterOutDiagnosticsForInbuiltRuntimeFunctions(
+              defaultDiagnostics,
+              fileContent,
+          )
+        : [];
+}
+
+function filterDiagnosticsForJsFile(
+    info: ts.server.PluginCreateInfo,
+    fileName: string,
+    defaultDiagnostics: AnyDiagnostic[],
+) {
+    if (fileName.includes(getTempJsFileBaseNameWithoutExtension())) {
+        // Filter out all diagnostics for temp js files.
+        return [];
+    } else if (!isInABrunoCollection(info, fileName)) {
+        return defaultDiagnostics;
+    }
+
+    const fileContent = getFileContent(info, fileName);
+
+    if (!fileContent) {
+        return [];
+    }
+
+    const filteredDiagnostics = filterOutDiagnosticsForInbuiltRuntimeFunctions(
+        defaultDiagnostics,
+        fileContent,
+    );
+
+    return filteredDiagnostics.map((diagnostic) => {
+        const { relatedInformation } = diagnostic;
+
+        const referencesTempJsFile =
+            relatedInformation &&
+            relatedInformation.some(
+                ({ file }) =>
+                    file &&
+                    file.fileName.endsWith(
+                        `${getTempJsFileBaseNameWithoutExtension()}.js`,
+                    ),
+            );
+
+        return referencesTempJsFile
+            ? { ...diagnostic, relatedInformation: undefined }
+            : diagnostic;
+    });
+}
+
+function filterOutDiagnosticsForInbuiltRuntimeFunctions(
+    diagnosticsToFilter: AnyDiagnostic[],
+    fileContent: string,
+) {
+    return filterOutMisleadingDiagnosticsForOtherTestFrameworks(
+        diagnosticsToFilter,
+    ).filter(
+        ({ start, length }) =>
+            start != undefined &&
+            length != undefined &&
+            // Do not show diagnostics for functions that are provided by Bruno at runtime
+            !getNamesForInbuiltRuntimeVarsAndFunctions().includes(
+                fileContent.substring(start, start + length),
+            ) &&
+            // Avoid showing incorrect error when using `require`
+            // (the error seems to only occur for short periods of time when typescript type definitions have not been reloaded for a while)
+            fileContent.substring(start, start + length) != "require",
+    );
+}
+
+function filterOutMisleadingDiagnosticsForOtherTestFrameworks(
+    diagnostics: AnyDiagnostic[],
+) {
+    return diagnostics.filter(({ code, messageText }) => {
+        const errorText =
+            typeof messageText == "string"
+                ? messageText
+                : messageText.messageText;
+
+        // When using global type definitions for Jest, the TS server expects every `expect` statement to use the matchers for Jest.
+        return code != 2_339 || !errorText.includes("JestMatchers<any>");
+    });
+}

package/src/fileContent.ts

@@ -0,0 +1,38 @@
+import * as ts from "typescript/lib/tsserverlibrary";
+
+export const originalSnapshotGettersForHosts = new WeakMap<
+    ts.LanguageServiceHost,
+    (fileName: string) => ts.IScriptSnapshot | undefined
+>();
+
+export function getFileContent(
+    info: ts.server.PluginCreateInfo,
+    fileName: string,
+) {
+    const scriptSnapshot = info.languageServiceHost.getScriptSnapshot(fileName);
+
+    if (scriptSnapshot) {
+        return scriptSnapshot.getText(0, scriptSnapshot.getLength());
+    } else {
+        return info.languageServiceHost.readFile(fileName);
+    }
+}
+
+/**
+ * For Yaml files, the content returned by the language service host is masked (see `maskYamlFilesForTypescriptServer`).
+ */
+export function getOriginalFileContent(
+    info: ts.server.PluginCreateInfo,
+    fileName: string,
+) {
+    const getOriginalSnapshot = originalSnapshotGettersForHosts.get(
+        info.languageServiceHost,
+    );
+    const scriptSnapshot = getOriginalSnapshot
+        ? getOriginalSnapshot(fileName)
+        : info.languageServiceHost.getScriptSnapshot(fileName);
+
+    return scriptSnapshot
+        ? scriptSnapshot.getText(0, scriptSnapshot.getLength())
+        : info.languageServiceHost.readFile(fileName);
+}

package/src/fileTypes.ts

@@ -0,0 +1,13 @@
+import { extname } from "path";
+
+export function hasEmbeddedCodeBlocks(fileName: string) {
+    return isBruFile(fileName) || isYamlFile(fileName);
+}
+
+export function isBruFile(fileName: string) {
+    return extname(fileName) == ".bru";
+}
+
+export function isYamlFile(fileName: string) {
+    return [".yml", ".yaml"].includes(extname(fileName));
+}

package/src/index.test.ts

@@ -0,0 +1,329 @@
+import { describe, it, expect } from "@jest/globals";
+import { dirname } from "path";
+import * as ts from "typescript/lib/tsserverlibrary";
+import init = require("./index");
+import { PluginConfig } from "./pluginConfiguration";
+
+const helperModule = `function helper() {
+    return 1;
+}
+
+module.exports = { helper };
+`;
+
+describe("code fixes and refactorings", () => {
+    describe.each([
+        {
+            format: "bru",
+            collectionRootFile: {
+                name: "bruno.json",
+                content: '{ "type": "collection" }',
+            },
+            requestFileName: "request.bru",
+            indentationForExtractedConstant: { spaces: "    ", tabs: "\t" },
+            requestFileContent: `meta {
+  name: request
+}
+
+script:pre-request {
+  const value = 1;
+  const text = "a" + value;
+  valeu;
+  helper();
+}
+`,
+        },
+        {
+            format: "yaml",
+            collectionRootFile: {
+                name: "opencollection.yml",
+                content: "opencollection: 1.0.0\n",
+            },
+            requestFileName: "request.yml",
+            // A line with less indentation than the script would end the Yaml block scalar. Tabs are not allowed for indenting Yaml content.
+            indentationForExtractedConstant: {
+                spaces: "        ",
+                tabs: "        ",
+            },
+            requestFileContent: `info:
+  name: request
+runtime:
+  scripts:
+    - type: before-request
+      code: |-
+        const value = 1;
+        const text = "a" + value;
+        valeu;
+        helper();
+    - type: tests
+      code: |-
+        test("x", () => {});
+`,
+        },
+    ])(
+        "for $format files",
+        ({
+            collectionRootFile,
+            requestFileName,
+            indentationForExtractedConstant,
+            requestFileContent,
+        }) => {
+            const collectionFiles = {
+                [`/collection/${collectionRootFile.name}`]:
+                    collectionRootFile.content,
+                "/collection/lib/helper.js": helperModule,
+                [`/collection/${requestFileName}`]: requestFileContent,
+            };
+            const requestFile = `/collection/${requestFileName}`;
+
+            it("provides code fixes that only change code within code blocks", () => {
+                const languageService =
+                    createLanguageServiceWithPlugin(collectionFiles);
+
+                expect(
+                    getCodeFixNames(
+                        languageService,
+                        requestFile,
+                        requestFileContent,
+                        "valeu",
+                    ),
+                ).toEqual(["spelling"]);
+            });
+
+            it("does not provide code fixes that insert code outside of code blocks", () => {
+                const languageService =
+                    createLanguageServiceWithPlugin(collectionFiles);
+
+                // Without filtering, an import would be added at the top of the file and a function declaration at the end of the file.
+                expect(
+                    getCodeFixNames(
+                        languageService,
+                        requestFile,
+                        requestFileContent,
+                        "helper",
+                    ),
+                ).toEqual([]);
+            });
+
+            it("provides edits for refactorings that only change code within code blocks", () => {
+                const languageService =
+                    createLanguageServiceWithPlugin(collectionFiles);
+
+                expect(
+                    getEditsForRefactor(
+                        languageService,
+                        requestFile,
+                        getSelection(requestFileContent, '"a" + value'),
+                        "Convert to template string",
+                    ),
+                ).toBeDefined();
+            });
+
+            it("does not provide edits for refactorings that insert code outside of code blocks", () => {
+                const languageService =
+                    createLanguageServiceWithPlugin(collectionFiles);
+
+                // Without filtering, the function would be added at the end of the file.
+                expect(
+                    getEditsForRefactor(
+                        languageService,
+                        requestFile,
+                        getSelection(requestFileContent, '"a" + value'),
+                        "Extract to function in global scope",
+                    ),
+                ).toBeUndefined();
+            });
+
+            it.each([
+                { indentationStyle: "spaces", convertTabsToSpaces: true },
+                { indentationStyle: "tabs", convertTabsToSpaces: false },
+            ] as const)(
+                "provides edits for extracting constants that keep the indentation of the code block when indenting with $indentationStyle",
+                ({ indentationStyle, convertTabsToSpaces }) => {
+                    const languageService =
+                        createLanguageServiceWithPlugin(collectionFiles);
+
+                    const edits = getEditsForRefactor(
+                        languageService,
+                        requestFile,
+                        getSelection(requestFileContent, '"a" + value'),
+                        "Extract to constant in enclosing scope",
+                        { convertTabsToSpaces },
+                    );
+
+                    expect(
+                        edits?.edits.flatMap(({ textChanges }) =>
+                            textChanges.map(({ newText }) => newText),
+                        ),
+                    ).toContain(
+                        `${indentationForExtractedConstant[indentationStyle]}const newLocal = "a" + value;\n`,
+                    );
+                },
+            );
+        },
+    );
+});
+
+describe("Yaml collection support", () => {
+    const requestFile = "/collection/request.yml";
+    const collectionFiles = {
+        "/collection/opencollection.yml": "opencollection: 1.0.0\n",
+        [requestFile]: `runtime:
+  scripts:
+    - type: tests
+      code: |-
+        valeu;
+`,
+    };
+
+    it("only provides diagnostics for scripts in Yaml files once Yaml collections are supported", () => {
+        const plugin = createPlugin({ yamlCollectionSupport: false });
+        const languageService = createLanguageServiceWithPlugin(
+            collectionFiles,
+            plugin,
+        );
+
+        expect(languageService.getSemanticDiagnostics(requestFile)).toEqual([]);
+
+        plugin.onConfigurationChanged({ yamlCollectionSupport: true });
+
+        expect(
+            languageService
+                .getSemanticDiagnostics(requestFile)
+                .map(({ code }) => code),
+        ).toEqual([2_304]); // Cannot find name 'valeu'.
+    });
+
+    it("does not provide formatting edits for Yaml files", () => {
+        const languageService =
+            createLanguageServiceWithPlugin(collectionFiles);
+
+        expect(
+            languageService.getFormattingEditsForDocument(
+                requestFile,
+                ts.getDefaultFormatCodeSettings(),
+            ),
+        ).toEqual([]);
+    });
+});
+
+function createLanguageServiceWithPlugin(
+    files: Record<string, string>,
+    plugin = createPlugin({ yamlCollectionSupport: true }),
+) {
+    const languageServiceHost: ts.LanguageServiceHost = {
+        getScriptFileNames: () =>
+            Object.keys(files).filter(
+                (fileName) => !fileName.endsWith(".json"),
+            ),
+        getScriptVersion: () => "1",
+        getScriptSnapshot: (fileName) => {
+            const content = files[fileName] ?? ts.sys.readFile(fileName);
+
+            return content != undefined
+                ? ts.ScriptSnapshot.fromString(content)
+                : undefined;
+        },
+        getCurrentDirectory: () => "/collection",
+        // Like for inferred projects of the Typescript server, files with any extension are handled.
+        getCompilationSettings: () => ({
+            allowJs: true,
+            allowNonTsExtensions: true,
+            target: ts.ScriptTarget.ES2020,
+        }),
+        getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+        fileExists: (fileName) =>
+            fileName in files || ts.sys.fileExists(fileName),
+        readFile: (fileName) => files[fileName] ?? ts.sys.readFile(fileName),
+    };
+    const serverHost = {
+        directoryExists: (directory: string) =>
+            Object.keys(files).some((fileName) =>
+                fileName.startsWith(`${directory}/`),
+            ),
+        readDirectory: (directory: string) =>
+            Object.keys(files).filter(
+                (fileName) => dirname(fileName) == directory,
+            ),
+    } as unknown as ts.server.ServerHost;
+
+    return plugin.create({
+        languageService: ts.createLanguageService(languageServiceHost),
+        languageServiceHost,
+        serverHost,
+    } as ts.server.PluginCreateInfo);
+}
+
+function createPlugin(config: PluginConfig) {
+    const plugin = init({ typescript: ts });
+    plugin.onConfigurationChanged(config);
+
+    return plugin;
+}
+
+function getCodeFixNames(
+    languageService: ts.LanguageService,
+    fileName: string,
+    fileContent: string,
+    diagnosticText: string,
+) {
+    const diagnostic = languageService
+        .getSemanticDiagnostics(fileName)
+        .find(
+            ({ start, length }) =>
+                start != undefined &&
+                length != undefined &&
+                fileContent.substring(start, start + length) == diagnosticText,
+        );
+
+    if (!diagnostic || diagnostic.start == undefined) {
+        throw new Error(`No diagnostic found for '${diagnosticText}'.`);
+    }
+
+    return languageService
+        .getCodeFixesAtPosition(
+            fileName,
+            diagnostic.start,
+            diagnostic.start + (diagnostic.length ?? 0),
+            [diagnostic.code],
+            ts.getDefaultFormatCodeSettings(),
+            {},
+        )
+        .map(({ fixName }) => fixName);
+}
+
+function getSelection(fileContent: string, selectedText: string) {
+    const start = fileContent.indexOf(selectedText);
+
+    return { pos: start, end: start + selectedText.length };
+}
+
+function getEditsForRefactor(
+    languageService: ts.LanguageService,
+    fileName: string,
+    selection: ts.TextRange,
+    actionDescription: string,
+    formatOptions?: ts.FormatCodeSettings,
+) {
+    const applicableRefactor = languageService
+        .getApplicableRefactors(fileName, selection, {})
+        .flatMap(({ name, actions }) =>
+            actions.map((action) => ({ refactorName: name, action })),
+        )
+        .find(({ action }) => action.description == actionDescription);
+
+    if (!applicableRefactor) {
+        throw new Error(
+            `Refactoring '${actionDescription}' is not applicable.`,
+        );
+    }
+
+    return languageService.getEditsForRefactor(
+        fileName,
+        { ...ts.getDefaultFormatCodeSettings(), ...formatOptions },
+        selection,
+        applicableRefactor.refactorName,
+        applicableRefactor.action.name,
+        {},
+    );
+}