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

package/src/languageService/formattingOverrides.ts

@@ -0,0 +1,42 @@
+import * as ts from "typescript/lib/tsserverlibrary";
+import { isYamlFile } from "../fileTypes";
+
+// The Typescript server only sees the masked content of Yaml files (see `maskYamlFilesForTypescriptServer`).
+// Formatting edits are computed for the masked content and would therefore remove the Yaml content outside of scripts.
+export function overrideFormatting(
+    info: ts.server.PluginCreateInfo,
+    proxy: ts.LanguageService,
+) {
+    proxy.getFormattingEditsForDocument = (fileName, options) =>
+        isYamlFile(fileName)
+            ? []
+            : info.languageService.getFormattingEditsForDocument(
+                  fileName,
+                  options,
+              );
+
+    proxy.getFormattingEditsForRange = (fileName, start, end, options) =>
+        isYamlFile(fileName)
+            ? []
+            : info.languageService.getFormattingEditsForRange(
+                  fileName,
+                  start,
+                  end,
+                  options,
+              );
+
+    proxy.getFormattingEditsAfterKeystroke = (
+        fileName,
+        position,
+        key,
+        options,
+    ) =>
+        isYamlFile(fileName)
+            ? []
+            : info.languageService.getFormattingEditsAfterKeystroke(
+                  fileName,
+                  position,
+                  key,
+                  options,
+              );
+}

package/src/languageService/navigationOverrides.ts

@@ -0,0 +1,201 @@
+import { extname } from "path";
+import * as ts from "typescript/lib/tsserverlibrary";
+import { isInABrunoCollection } from "../collection/collectionFormat";
+import { getTempJsFileBaseNameWithoutExtension } from "../constants";
+import { hasEmbeddedCodeBlocks } from "../fileTypes";
+
+export function overrideHoverAndCompletions(
+    info: ts.server.PluginCreateInfo,
+    proxy: ts.LanguageService,
+) {
+    // All hovers are provided by the extension implementation for '.bru' and '.yml' files.
+    proxy.getQuickInfoAtPosition = (fileName, position) => {
+        if (hasEmbeddedCodeBlocks(fileName)) {
+            return undefined;
+        }
+
+        return info.languageService.getQuickInfoAtPosition(fileName, position);
+    };
+
+    proxy.getCompletionsAtPosition = (fileName, position, options) => {
+        // All completions are provided by the extension implementation for '.bru' and '.yml' files.
+        if (hasEmbeddedCodeBlocks(fileName)) {
+            return undefined;
+        }
+
+        const defaultCompletions =
+            info.languageService.getCompletionsAtPosition(
+                fileName,
+                position,
+                options,
+            );
+
+        return defaultCompletions && isInABrunoCollection(info, fileName)
+            ? {
+                  ...defaultCompletions,
+                  entries: defaultCompletions.entries.filter(
+                      ({ data }) =>
+                          !data ||
+                          !data.fileName ||
+                          !data.fileName.includes(
+                              getTempJsFileBaseNameWithoutExtension(),
+                          ),
+                  ),
+              }
+            : defaultCompletions;
+    };
+}
+
+export function overrideRename(
+    info: ts.server.PluginCreateInfo,
+    proxy: ts.LanguageService,
+) {
+    proxy.getRenameInfo = (fileName, position, preferences) => {
+        const defaultRenameInfo = info.languageService.getRenameInfo(
+            fileName,
+            position,
+            preferences as ts.UserPreferences,
+        );
+
+        if (
+            extname(fileName) != ".js" ||
+            !isInABrunoCollection(info, fileName)
+        ) {
+            return defaultRenameInfo;
+        }
+
+        const definitionForPosition =
+            info.languageService.getDefinitionAtPosition(fileName, position);
+
+        const isForInbuiltRuntimeFunction =
+            definitionForPosition &&
+            definitionForPosition.some(({ fileName }) =>
+                fileName.includes(getTempJsFileBaseNameWithoutExtension()),
+            );
+
+        return isForInbuiltRuntimeFunction
+            ? {
+                  canRename: false,
+                  localizedErrorMessage:
+                      "You cannot rename elements that are provided by Bruno at runtime.",
+              }
+            : defaultRenameInfo;
+    };
+
+    proxy.findRenameLocations = (
+        fileName,
+        position,
+        findInStrings,
+        findInComments,
+        providePrefixAndSuffixTextForRename,
+    ) => {
+        const defaultRenameLocations = info.languageService.findRenameLocations(
+            fileName,
+            position,
+            findInStrings,
+            findInComments,
+            providePrefixAndSuffixTextForRename &&
+                typeof providePrefixAndSuffixTextForRename != "boolean"
+                ? providePrefixAndSuffixTextForRename
+                : {},
+        );
+
+        return defaultRenameLocations && isInABrunoCollection(info, fileName)
+            ? defaultRenameLocations.filter(
+                  ({ fileName: fileForRenameLocation }) =>
+                      !fileForRenameLocation.includes(
+                          getTempJsFileBaseNameWithoutExtension(),
+                      ),
+              )
+            : defaultRenameLocations;
+    };
+}
+
+export function overrideReferencesAndDefinitions(
+    info: ts.server.PluginCreateInfo,
+    proxy: ts.LanguageService,
+) {
+    proxy.findReferences = (fileName, position) => {
+        const defaultReferences = info.languageService.findReferences(
+            fileName,
+            position,
+        );
+
+        return defaultReferences && isInABrunoCollection(info, fileName)
+            ? defaultReferences.filter(
+                  ({ definition: { fileName: fileForDefinition } }) =>
+                      !fileForDefinition.includes(
+                          getTempJsFileBaseNameWithoutExtension(),
+                      ),
+              )
+            : defaultReferences;
+    };
+
+    proxy.getDefinitionAtPosition = (fileName, position) => {
+        const defaultDefinitions = info.languageService.getDefinitionAtPosition(
+            fileName,
+            position,
+        );
+
+        return defaultDefinitions && isInABrunoCollection(info, fileName)
+            ? defaultDefinitions.filter(
+                  ({ fileName: fileForDefinition }) =>
+                      !fileForDefinition.includes(
+                          getTempJsFileBaseNameWithoutExtension(),
+                      ),
+              )
+            : defaultDefinitions;
+    };
+
+    proxy.getDefinitionAndBoundSpan = (fileName, position) => {
+        const defaultDefinition =
+            info.languageService.getDefinitionAndBoundSpan(fileName, position);
+
+        return defaultDefinition &&
+            isInABrunoCollection(info, fileName) &&
+            defaultDefinition.definitions
+            ? {
+                  ...defaultDefinition,
+                  definitions: defaultDefinition.definitions.filter(
+                      ({ fileName: fileForDefinition }) =>
+                          !fileForDefinition.includes(
+                              getTempJsFileBaseNameWithoutExtension(),
+                          ),
+                  ),
+              }
+            : defaultDefinition;
+    };
+
+    proxy.getTypeDefinitionAtPosition = (fileName, position) => {
+        const defaultDefinitions = info.languageService.getDefinitionAtPosition(
+            fileName,
+            position,
+        );
+
+        return defaultDefinitions && isInABrunoCollection(info, fileName)
+            ? defaultDefinitions.filter(
+                  ({ fileName: fileForDefinition }) =>
+                      !fileForDefinition.includes(
+                          getTempJsFileBaseNameWithoutExtension(),
+                      ),
+              )
+            : defaultDefinitions;
+    };
+
+    proxy.getImplementationAtPosition = (fileName, position) => {
+        const defaultImplementations =
+            info.languageService.getImplementationAtPosition(
+                fileName,
+                position,
+            );
+
+        return defaultImplementations && isInABrunoCollection(info, fileName)
+            ? defaultImplementations.filter(
+                  ({ fileName: fileForImplementation }) =>
+                      !fileForImplementation.includes(
+                          getTempJsFileBaseNameWithoutExtension(),
+                      ),
+              )
+            : defaultImplementations;
+    };
+}

package/src/pluginConfiguration.ts

@@ -0,0 +1,34 @@
+export interface PluginConfig {
+    yamlCollectionSupport: boolean;
+}
+
+/**
+ * The configuration is passed to the plugin by the VS Code extension (see `configureTsServerPlugin` in the client).
+ * As long as no configuration is passed, Yaml collections are not supported.
+ */
+export class PluginConfiguration {
+    private config: PluginConfig = { yamlCollectionSupport: false };
+    private readonly changeListeners: (() => void)[] = [];
+
+    isYamlCollectionSupportEnabled() {
+        return this.config.yamlCollectionSupport;
+    }
+
+    onDidChange(listener: () => void) {
+        this.changeListeners.push(listener);
+    }
+
+    update(config: Partial<PluginConfig> | undefined) {
+        const yamlCollectionSupport = config?.yamlCollectionSupport == true;
+
+        if (yamlCollectionSupport == this.config.yamlCollectionSupport) {
+            return;
+        }
+
+        this.config = { yamlCollectionSupport };
+
+        for (const listener of this.changeListeners) {
+            listener();
+        }
+    }
+}

package/src/yamlFiles/getIndentationOfScripts.ts

@@ -0,0 +1,34 @@
+import { getScriptContentRanges } from "./maskYamlFileContent";
+
+/**
+ * Returns the indentation of the scripts that overlap with the given range, if all of them use the same indentation.
+ *
+ * The indentation of a literal block scalar is the minimal indentation of its non-empty lines.
+ * Lines with this indentation are always part of the block scalar, even if it uses an explicit indentation indicator (e.g. `code: |2-`).
+ */
+export function getIndentationOfScripts(
+    fileName: string,
+    fileContent: string,
+    range: { start: number; end: number },
+) {
+    const indentations = new Set(
+        getScriptContentRanges(fileName, fileContent)
+            .filter(
+                ({ start, end }) => start <= range.end && range.start <= end,
+            )
+            .map(({ start, end }) =>
+                getMinimalIndentation(fileContent.substring(start, end)),
+            ),
+    );
+
+    return indentations.size == 1 ? [...indentations][0] : undefined;
+}
+
+function getMinimalIndentation(scriptContent: string) {
+    const indentations = scriptContent
+        .split(/\r\n|\r|\n|\u2028|\u2029/)
+        .filter((line) => line.trim().length > 0)
+        .map((line) => /^ */.exec(line)![0].length);
+
+    return indentations.length > 0 ? Math.min(...indentations) : undefined;
+}

package/src/yamlFiles/maskYamlFileContent.test.ts

@@ -0,0 +1,213 @@
+import { describe, it, expect } from "@jest/globals";
+import * as ts from "typescript";
+import {
+    maskYamlCollectionFileContent,
+    maskYamlFileContent,
+} from "./maskYamlFileContent";
+
+describe("maskYamlCollectionFileContent", () => {
+    it("keeps only the code of scripts in request files and wraps each script in a block", () => {
+        const content = `info:
+  name: test
+runtime:
+  scripts:
+    - type: before-request
+      code: |-
+        const a = 1;
+    - type: tests
+      code: |
+        test("x", () => {});
+`;
+
+        expect(
+            maskYamlCollectionFileContent("request.yml", content).split("\n"),
+        ).toEqual([
+            blank("info:"),
+            blank("  name: test"),
+            blank("runtime:"),
+            blank("  scripts:"),
+            blank("    - type: before-request"),
+            blank("      code: |") + "{",
+            "        const a = 1;",
+            "}" + blank("   - type: tests"),
+            blank("      code: ") + "{",
+            '        test("x", () => {});',
+            "}",
+        ]);
+    });
+
+    it("keeps the code of scripts in folder and collection settings files", () => {
+        const content = `meta:
+  name: folder
+request:
+  scripts:
+    - type: after-response
+      code: |-
+        bru.setVar("a", res.status);`;
+
+        expect(
+            maskYamlCollectionFileContent("folder.yml", content).split("\n"),
+        ).toEqual([
+            blank("meta:"),
+            blank("  name: folder"),
+            blank("request:"),
+            blank("  scripts:"),
+            blank("    - type: after-response"),
+            blank("      code: |") + "{",
+            '        bru.setVar("a", res.status);',
+            "}",
+        ]);
+    });
+
+    it("keeps the code of scripts in collection settings files", () => {
+        const content = `opencollection: 1.0.0
+request:
+  scripts:
+    - type: before-request
+      code: |-
+        bru.setVar("a", 1);
+`;
+
+        expect(
+            maskYamlCollectionFileContent("opencollection.yml", content).split(
+                "\n",
+            ),
+        ).toEqual([
+            blank("opencollection: 1.0.0"),
+            blank("request:"),
+            blank("  scripts:"),
+            blank("    - type: before-request"),
+            blank("      code: |") + "{",
+            '        bru.setVar("a", 1);',
+            "}",
+        ]);
+    });
+
+    it("does not add the closing bracket of the last script to a line comment at the end of the file", () => {
+        const content = `runtime:
+  scripts:
+    - type: tests
+      code: |-
+        test(); // comment`;
+
+        const sourceFile = ts.createSourceFile(
+            "test.ts",
+            maskYamlCollectionFileContent("request.yml", content),
+            ts.ScriptTarget.Latest,
+        );
+
+        expect(getSyntacticDiagnostics(sourceFile)).toEqual([]);
+    });
+
+    it("masks scripts with a missing or invalid type", () => {
+        const content = `runtime:
+  scripts:
+    - code: |-
+        const a = 1;
+    - type: before-requset
+      code: |-
+        const b = 2;
+`;
+
+        expect(
+            maskYamlCollectionFileContent("request.yml", content).trim(),
+        ).toBe("");
+    });
+
+    it.each([
+        { fileName: "request.yml", maskedSection: "request" },
+        { fileName: "folder.yml", maskedSection: "runtime" },
+    ])(
+        "masks scripts in the '$maskedSection' section for $fileName",
+        ({ fileName, maskedSection }) => {
+            const content = `${maskedSection}:
+  scripts:
+    - type: tests
+      code: |-
+        test();
+`;
+
+            expect(
+                maskYamlCollectionFileContent(fileName, content).trim(),
+            ).toBe("");
+        },
+    );
+
+    it("keeps line breaks of all kinds", () => {
+        const content =
+            "runtime:\r\n  scripts:\r\n    - type: tests\r\n      code: |-\r\n        test();\r\n";
+
+        expect(
+            maskYamlCollectionFileContent("request.yml", content).split("\r\n"),
+        ).toEqual([
+            blank("runtime:"),
+            blank("  scripts:"),
+            blank("    - type: tests"),
+            blank("      code: |") + "{",
+            "        test();",
+            "}",
+        ]);
+    });
+
+    it("masks scripts that are not defined as literal block scalars", () => {
+        const content = `runtime:
+  scripts:
+    - type: before-request
+      code: "bru.setVar('a', 1);"
+    - type: tests
+      code: >-
+        test("x", () => {});
+`;
+
+        const maskedContent = maskYamlCollectionFileContent(
+            "request.yml",
+            content,
+        );
+
+        expect(maskedContent).toHaveLength(content.length);
+        expect(maskedContent.trim()).toBe("");
+    });
+
+    it("scopes declarations to the script they are defined in", () => {
+        const content = `runtime:
+  scripts:
+    - type: before-request
+      code: |-
+        const a = 1;
+    - type: after-response
+      code: |-
+        const a = 2;
+`;
+
+        const sourceFile = ts.createSourceFile(
+            "test.ts",
+            maskYamlCollectionFileContent("request.yml", content),
+            ts.ScriptTarget.Latest,
+        );
+
+        expect(sourceFile.statements.map(({ kind }) => kind)).toEqual([
+            ts.SyntaxKind.Block,
+            ts.SyntaxKind.Block,
+        ]);
+    });
+});
+
+describe("maskYamlFileContent", () => {
+    it("replaces all characters except for line breaks by spaces", () => {
+        expect(maskYamlFileContent("a: 1\r\nb:\n  - c\n")).toBe(
+            `${blank("a: 1")}\r\n${blank("b:")}\n${blank("  - c")}\n`,
+        );
+    });
+});
+
+function getSyntacticDiagnostics(sourceFile: ts.SourceFile) {
+    return (
+        sourceFile as unknown as {
+            parseDiagnostics: ts.DiagnosticWithLocation[];
+        }
+    ).parseDiagnostics;
+}
+
+function blank(text: string) {
+    return " ".repeat(text.length);
+}

package/src/yamlFiles/maskYamlFileContent.ts

@@ -0,0 +1,179 @@
+import { basename } from "path";
+import { Document, isMap, isScalar, isSeq, parseDocument, Scalar } from "yaml";
+import { ScriptType } from "../constants";
+
+/**
+ * Returns the content of a Yaml file from a Bruno collection the way it should be seen by the Typescript server.
+ *
+ * All characters that are not part of a script's code are replaced by spaces.
+ * Line breaks are kept, so that all offsets and line / character positions are equal to the ones in the original content.
+ * Each script is wrapped in a block (`{ ... }`), so that its declarations are scoped like the ones in code blocks of `.bru` files.
+ *
+ * Only the scripts returned by `getScriptContentRanges` are kept.
+ */
+export function maskYamlCollectionFileContent(
+    fileName: string,
+    fileContent: string,
+) {
+    const maskedCharacters = maskYamlFileContent(fileContent).split("");
+    const scriptRanges = getScriptContentRanges(fileName, fileContent);
+    let firstFreeIndex = 0;
+    let suffix = "";
+
+    for (const [index, { start, end }] of scriptRanges.entries()) {
+        const isLastScript = index == scriptRanges.length - 1;
+
+        const openingBracketIndex = findLastIndexWithoutLineBreak(
+            fileContent,
+            firstFreeIndex,
+            start,
+        );
+        const closingBracketIndex = findFirstIndexWithoutLineBreak(
+            fileContent,
+            end,
+            isLastScript ? fileContent.length : scriptRanges[index + 1].start,
+        );
+
+        if (
+            openingBracketIndex == undefined ||
+            (closingBracketIndex == undefined && !isLastScript)
+        ) {
+            continue;
+        }
+
+        for (let i = start; i < end; i++) {
+            maskedCharacters[i] = fileContent[i];
+        }
+
+        maskedCharacters[openingBracketIndex] = "{";
+
+        if (closingBracketIndex == undefined) {
+            // Appending characters at the end does not shift any positions.
+            // A line break is needed if the script ends at the end of the file, since the closing bracket could otherwise be part of a line comment.
+            suffix = isLineBreak(fileContent[fileContent.length - 1])
+                ? "}"
+                : "\n}";
+        } else {
+            maskedCharacters[closingBracketIndex] = "}";
+            firstFreeIndex = closingBracketIndex + 1;
+        }
+    }
+
+    return maskedCharacters.join("").concat(suffix);
+}
+
+/**
+ * Replaces all characters except for line breaks by spaces, so that the Typescript server does not provide any language features for the file.
+ */
+export function maskYamlFileContent(fileContent: string) {
+    return fileContent.replace(/[^\r\n\u2028\u2029]/g, " ");
+}
+
+/**
+ * Scripts are defined in `runtime.scripts` for request files and in `request.scripts` for folder and collection settings files.
+ *
+ * The same scripts are returned as by `getScriptBlocksFromYamlFile` in the shared folder of the extension:
+ * Only scripts with a valid type that are defined as literal block scalars (`code: |`) are included.
+ * For all other scalar styles, the raw text in the file is not equal to the code (e.g. due to quotes or line folding).
+ */
+export function getScriptContentRanges(fileName: string, fileContent: string) {
+    const document = parseDocument(fileContent);
+    const scripts = document.getIn(
+        isSettingsFile(fileName, document)
+            ? ["request", "scripts"]
+            : ["runtime", "scripts"],
+        true,
+    );
+
+    return (isSeq(scripts) ? scripts.items : [])
+        .flatMap((script) => {
+            if (!isMap(script) || !isValidScriptType(script.get("type"))) {
+                return [];
+            }
+
+            const code = script.get("code", true);
+
+            if (
+                !isScalar(code) ||
+                code.type != Scalar.BLOCK_LITERAL ||
+                !code.range
+            ) {
+                return [];
+            }
+
+            const [headerStart, valueEnd] = code.range;
+            const range = getContentRangeForBlockScalar(
+                fileContent,
+                headerStart,
+                valueEnd,
+            );
+
+            return range ? [range] : [];
+        })
+        .sort(({ start: start1 }, { start: start2 }) => start1 - start2);
+}
+
+/**
+ * Folder settings files are always named `folder.yml`.
+ * The collection settings file is the only file that defines the top-level key `opencollection`.
+ */
+function isSettingsFile(fileName: string, document: Document) {
+    return basename(fileName) == "folder.yml" || document.has("opencollection");
+}
+
+function isValidScriptType(type: unknown) {
+    return (Object.values(ScriptType) as unknown[]).includes(type);
+}
+
+/**
+ * The range of a block scalar node starts with the header (e.g. `|-`), which is followed by the content on the next lines.
+ */
+function getContentRangeForBlockScalar(
+    fileContent: string,
+    headerStart: number,
+    valueEnd: number,
+) {
+    const lineBreakAfterHeader = /\r\n|\r|\n|\u2028|\u2029/g;
+    lineBreakAfterHeader.lastIndex = headerStart;
+    const match = lineBreakAfterHeader.exec(fileContent);
+
+    if (!match) {
+        return undefined;
+    }
+
+    const start = match.index + match[0].length;
+
+    return start < valueEnd ? { start, end: valueEnd } : undefined;
+}
+
+function findLastIndexWithoutLineBreak(
+    text: string,
+    startIndex: number,
+    endIndexExclusive: number,
+) {
+    for (let i = endIndexExclusive - 1; i >= startIndex; i--) {
+        if (!isLineBreak(text[i])) {
+            return i;
+        }
+    }
+
+    return undefined;
+}
+
+function findFirstIndexWithoutLineBreak(
+    text: string,
+    startIndex: number,
+    endIndexExclusive: number,
+) {
+    for (let i = startIndex; i < endIndexExclusive; i++) {
+        if (!isLineBreak(text[i])) {
+            return i;
+        }
+    }
+
+    return undefined;
+}
+
+function isLineBreak(character: string) {
+    return ["\r", "\n", "\u2028", "\u2029"].includes(character);
+}