The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
feat(plugins): when clauses that test whether the project contains a file (#1620)
Arnaud Ritti7bd96a998b05
diff --git a/crates/ide-extension/src/when.rs b/crates/ide-extension/src/when.rsindex 98cd3c931..b6a75d638 100644--- a/crates/ide-extension/src/when.rs+++ b/crates/ide-extension/src/when.rs@@ -98,7 +98,15 @@ fn parse_unary(t: &[Tok], p: &mut usize, src: &str) -> Result<(), String> {*p += 1;Ok(())}- Some(Tok::Id(_)) => {+ Some(Tok::Id(id)) => {+ if let Some(path) = id.strip_prefix("workspaceContains:")+ && (path.is_empty()+ || path.starts_with('/')+ || path.contains('\\')+ || path.split('/').any(|s| s == ".."))+ {+ return Err(format!("workspaceContains: needs a relative path inside the project: {src}"));+ }*p += 1;if matches!(t.get(*p), Some(Tok::Op("==" | "!="))) {*p += 1;@@ -133,4 +141,23 @@ mod tests {assert!(validate_when(bad).is_err(), "{bad}");}}++ #[test]+ fn workspace_contains_paths_stay_in_the_project() {+ for ok in [+ "workspaceContains:pom.xml",+ "workspaceContains:.devcontainer/devcontainer.json",+ "!workspaceContains:a/b && editorFocus",+ ] {+ assert!(validate_when(ok).is_ok(), "{ok}");+ }+ for bad in [+ "workspaceContains:",+ "workspaceContains:/etc/passwd",+ "workspaceContains:../x",+ "workspaceContains:a/../../x",+ ] {+ assert!(validate_when(bad).unwrap_err().contains("workspaceContains"), "{bad}");+ }+ }}diff --git a/plugins/README.md b/plugins/README.mdindex d2f1ab09d..5d5af6511 100644--- a/plugins/README.md+++ b/plugins/README.md@@ -152,6 +152,13 @@ is loaded. Menus, shortcuts and status bar items refer to the plugin'sdeclared commands. A plugin shortcut never takes a keystroke the IDE (or theuser) already uses; the user can rebind it in the keymap editor.+A `when` clause (on commands and menus) can test whether the open project+contains a file or folder: `when = "workspaceContains:.devcontainer/devcontainer.json"`.+The path is exact (no globs) and relative to the project root; in a workspace the+key is true when any of its projects contains the path. It updates when+files change. An IDE that doesn't know the key treats it as+false: the plugin still installs and the key reads as false there.+### ActivationCode is instantiated lazily: when one of the plugin's commands runs, or whendiff --git a/src/features/plugins/__tests__/workspaceContains.test.ts b/src/features/plugins/__tests__/workspaceContains.test.tsnew file mode 100644index 000000000..72b13b1ab--- /dev/null+++ b/src/features/plugins/__tests__/workspaceContains.test.ts@@ -0,0 +1,206 @@+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import { getContext, setContext } from "@/platform/context";+import { useProject } from "@/platform/project";+import { usePlugins } from "../store";+import {+ affectsWorkspaceContains,+ refreshWorkspaceContains,+ startWorkspaceContains,+ workspaceContainsKeys,+} from "../workspaceContains";++const ipc = vi.hoisted(() => ({+ handlers: {} as Record<string, (e: unknown) => void>,+ files: {} as Record<string, string[]>,+ readDir: vi.fn(),+}));+vi.mock("@/platform/ipc", () => ({+ call: (p: unknown) => p,+ isTauri: () => true,+ commands: { fsReadDir: (dir: string) => ipc.readDir(dir) },+ onIdeEvent: (name: string, handler: (e: unknown) => void) => {+ ipc.handlers[name] = handler;+ return () => {+ delete ipc.handlers[name];+ };+ },+}));++describe("workspaceContains", () => {+ it("collects keys from when clauses", () => {+ expect(+ workspaceContainsKeys([+ "workspaceContains:a/b.txt && editorFocus",+ null,+ "!workspaceContains:pom.xml",+ "workspaceContains:a/b.txt",+ ]),+ ).toEqual(["workspaceContains:a/b.txt", "workspaceContains:pom.xml"]);+ });++ it("sets each key from its parent folder's listing", async () => {+ const list = vi.fn(async (dir: string) => (dir === "/p/.devcontainer" ? ["devcontainer.json"] : ["src"]));+ await refreshWorkspaceContains(+ ["/p"],+ ["workspaceContains:.devcontainer/devcontainer.json", "workspaceContains:pom.xml"],+ list,+ );+ expect(getContext()["workspaceContains:.devcontainer/devcontainer.json"]).toBe(true);+ expect(getContext()["workspaceContains:pom.xml"]).toBe(false);+ expect(list).toHaveBeenCalledWith("/p");+ });++ it("is false without a project or when the folder can't be read", async () => {+ const list = vi.fn(async (): Promise<string[]> => {+ throw new Error("missing");+ });+ await refreshWorkspaceContains(["/p"], ["workspaceContains:x/y"], list);+ expect(getContext()["workspaceContains:x/y"]).toBe(false);+ setContext("workspaceContains:x/y", true);+ list.mockClear();+ await refreshWorkspaceContains([], ["workspaceContains:x/y"], list);+ expect(list).not.toHaveBeenCalled();+ expect(getContext()["workspaceContains:x/y"]).toBe(false);+ });++ it("is true when any root contains the path", async () => {+ const list = vi.fn(async (dir: string) => (dir === "/b" ? ["pom.xml"] : []));+ await refreshWorkspaceContains(["/a", "/b"], ["workspaceContains:pom.xml"], list);+ expect(getContext()["workspaceContains:pom.xml"]).toBe(true);+ });++ it("ignores keys that are absolute or climb out of the project, and a trailing slash", async () => {+ const list = vi.fn(async (dir: string) => (dir === "/p" ? [".devcontainer"] : []));+ await refreshWorkspaceContains(+ ["/p"],+ [+ "workspaceContains:/etc/passwd",+ "workspaceContains:../a",+ "workspaceContains:a/../../b",+ "workspaceContains:.devcontainer/",+ ],+ list,+ );+ expect(list).toHaveBeenCalledTimes(1);+ expect(list).toHaveBeenCalledWith("/p");+ expect(getContext()["workspaceContains:/etc/passwd"]).toBe(false);+ expect(getContext()["workspaceContains:../a"]).toBe(false);+ expect(getContext()["workspaceContains:a/../../b"]).toBe(false);+ expect(getContext()["workspaceContains:.devcontainer/"]).toBe(true);+ });++ it("only picks keys at a word boundary", () => {+ expect(workspaceContainsKeys(["xworkspaceContains:../a", "a && workspaceContains:b"])).toEqual([+ "workspaceContains:b",+ ]);+ });++ it("refreshes only when a watched path or one of its parents changes", () => {+ const keys = ["workspaceContains:.devcontainer/devcontainer.json"];+ const affects = (paths: string[], roots = ["/p"]) => affectsWorkspaceContains(paths, roots, keys);+ expect(affects(["/p2/x"])).toBe(false);+ expect(affects(["/p/src/a.ts"])).toBe(false);+ expect(affects(["/p/.devcontainer"])).toBe(true);+ expect(affects(["/p/.devcontainer/devcontainer.json"])).toBe(true);+ expect(affects(["/q/.devcontainer"], ["/p", "/q"])).toBe(true);+ expect(affects(["/p/.devcontainer"], [])).toBe(false);+ });++ it("ignores a stale refresh that resolves after a newer one", async () => {+ const key = "workspaceContains:pom.xml";+ let releaseOld: (names: string[]) => void = () => {};+ let releaseNew: (names: string[]) => void = () => {};+ const old = new Promise<string[]>((resolve) => (releaseOld = resolve));+ const fresh = new Promise<string[]>((resolve) => (releaseNew = resolve));+ let latest = 0;+ const first = refreshWorkspaceContains(+ ["/a"],+ [key],+ () => old,+ (+ (t) => () =>+ t === latest+ )(++latest),+ );+ const second = refreshWorkspaceContains(+ ["/b"],+ [key],+ () => fresh,+ (+ (t) => () =>+ t === latest+ )(++latest),+ );+ releaseNew(["pom.xml"]);+ await second;+ releaseOld([]);+ await first;+ expect(getContext()[key]).toBe(true);+ });+});++describe("startWorkspaceContains", () => {+ const key = "workspaceContains:.devcontainer/devcontainer.json";+ const setProject = (root: string) => useProject.setState({ project: { root, workspace: null } as never });+ const keyIs = (value: boolean) => vi.waitFor(() => expect(getContext()[key]).toBe(value));+ const emit = (name: string, event: unknown) => {+ const handler = ipc.handlers[name];+ if (!handler) {+ throw new Error(`no handler for ${name}`);+ }+ handler(event);+ };+ let stop: () => void;++ beforeEach(() => {+ ipc.files = { "/p": ["src"], "/q": [".devcontainer"], "/q/.devcontainer": ["devcontainer.json"] };+ ipc.readDir.mockReset();+ ipc.readDir.mockImplementation(async (dir: string) => (ipc.files[dir] ?? []).map((name) => ({ name })));+ usePlugins.setState({ ui: [{ pluginId: "x", point: "menus", key: "k", decl: { when: key } }] as never });+ setProject("/p");+ setContext(key, undefined);+ stop = startWorkspaceContains();+ });++ afterEach(() => stop());++ it("re-evaluates when the file is created and deleted", async () => {+ await keyIs(false);+ ipc.files["/p"] = [".devcontainer"];+ ipc.files["/p/.devcontainer"] = ["devcontainer.json"];+ emit("fsChanged", { created: ["/p/.devcontainer"], modified: [], removed: [] });+ await keyIs(true);++ ipc.files["/p/.devcontainer"] = [];+ emit("fsChanged", { created: [], modified: [], removed: ["/p/.devcontainer/devcontainer.json"] });+ await keyIs(false);+ });++ it("re-evaluates when the project changes", async () => {+ await keyIs(false);+ setProject("/q");+ await keyIs(true);+ });++ it.each([["/p/.devcontainer"], ["/p"]])("re-evaluates when ignored folder %s changes", async (dir) => {+ await keyIs(false);+ ipc.files["/p/.devcontainer"] = ["devcontainer.json"];+ emit("excludedDirsChanged", { dirs: [dir] });+ await keyIs(true);+ });++ it("ignores unrelated changes", async () => {+ await keyIs(false);+ ipc.readDir.mockClear();+ emit("fsChanged", { created: ["/p/src/a.ts"], modified: [], removed: [] });+ emit("excludedDirsChanged", { dirs: ["/p/node_modules"] });+ expect(ipc.readDir).not.toHaveBeenCalled();+ });++ it("stops listening when disposed", async () => {+ await keyIs(false);+ stop();+ expect(ipc.handlers.fsChanged).toBeUndefined();+ expect(ipc.handlers.excludedDirsChanged).toBeUndefined();+ });+});diff --git a/src/features/plugins/index.ts b/src/features/plugins/index.tsindex e659b68ec..bcf4c39eb 100644--- a/src/features/plugins/index.ts+++ b/src/features/plugins/index.ts@@ -33,6 +33,7 @@ import { defineBuiltinUiPoints } from "./points";import { startViewUi } from "./uiPoints";import { importIntellijTheme, showInstalledIntellijThemes } from "./intellijImport";import { IntellijThemesDialogHost } from "./IntellijThemesDialog";+import { startWorkspaceContains } from "./workspaceContains";import { installFromDisk, refreshPlugins, reloadPlugin, SETTINGS_PAGE_ID, updateAllPlugins, usePlugins } from "./store";function registerPluginsPage(): () => void {@@ -144,6 +145,7 @@ export function activate(): () => void {startPluginBridge(),// Plugin custom editors (tab kind) and context menu entries.startViewUi((input) => void editorService().openInput(input)),+ startWorkspaceContains(),// Gutter icons from plugins' `line-markers` providers (next to the LSP ones).registerEditorContribution({ id: "plugins.lineMarkers", order: 57, extensions: pluginLineMarkerGutter }),// Dev plugins (`<project>/.openidea/plugins`) depend on the open project.diff --git a/src/features/plugins/workspaceContains.ts b/src/features/plugins/workspaceContains.tsnew file mode 100644index 000000000..91104bdf8--- /dev/null+++ b/src/features/plugins/workspaceContains.ts@@ -0,0 +1,102 @@+import { setContext } from "@/platform/context";+import { call, commands, onIdeEvent } from "@/platform/ipc";+import { useProject } from "@/platform/project";+import { usePlugins } from "./store";++const PREFIX = "workspaceContains:";+// A whole identifier: at the start or after a character that can't be part of one.+const KEY = /(?:^|[^\w.\-:/])(workspaceContains:[\w.\-:/]+)/g;++export function workspaceContainsKeys(whens: readonly (string | null | undefined)[]): string[] {+ return [...new Set(whens.flatMap((when) => [...(when ?? "").matchAll(KEY)].map((m) => m[1]!)))];+}++function relativePath(key: string): string | null {+ const path = key.slice(PREFIX.length).replace(/\/+$/, "");+ if (!path || path.startsWith("/") || path.split("/").includes("..")) {+ return null;+ }+ return path;+}++export function affectsWorkspaceContains(+ changed: readonly string[],+ roots: readonly string[],+ keys: readonly string[],+): boolean {+ const targets = keys.flatMap((key) => {+ const path = relativePath(key);+ return path === null ? [] : roots.map((root) => `${root}/${path}`);+ });+ return changed.some((p) => targets.some((t) => t === p || t.startsWith(`${p}/`)));+}++export async function refreshWorkspaceContains(+ roots: readonly string[],+ keys: readonly string[],+ list: (dir: string) => Promise<string[]>,+ isCurrent: () => boolean = () => true,+): Promise<void> {+ const results = await Promise.all(+ keys.map(async (key) => {+ const path = relativePath(key);+ if (path === null) {+ return [key, false] as const;+ }+ const slash = path.lastIndexOf("/");+ const parent = slash < 0 ? "" : path.slice(0, slash);+ const name = path.slice(slash + 1);+ const found = await Promise.all(+ roots.map(async (root) => {+ const names: string[] = await list(parent ? `${root}/${parent}` : root).catch(() => []);+ return names.includes(name);+ }),+ );+ return [key, found.some(Boolean)] as const;+ }),+ );+ if (!isCurrent()) {+ return;+ }+ for (const [key, value] of results) {+ setContext(key, value);+ }+}++const listNames = (dir: string) => call(commands.fsReadDir(dir)).then((entries) => entries.map((e) => e.name));++const projectRoots = () => {+ const project = useProject.getState().project;+ return project?.workspace?.projects ?? (project ? [project.root] : []);+};++export function startWorkspaceContains(): () => void {+ let latest = 0;+ const currentKeys = () =>+ workspaceContainsKeys(usePlugins.getState().ui.map((u) => (u.decl as { when?: string | null }).when));+ const refresh = () => {+ const token = ++latest;+ void refreshWorkspaceContains(projectRoots(), currentKeys(), listNames, () => token === latest);+ };+ const disposers = [+ usePlugins.subscribe((s, prev) => {+ if (s.ui !== prev.ui) refresh();+ }),+ useProject.subscribe((s, prev) => {+ if (+ s.project?.root !== prev.project?.root ||+ s.project?.workspace?.projects.join("\n") !== prev.project?.workspace?.projects.join("\n")+ ) {+ refresh();+ }+ }),+ onIdeEvent("fsChanged", (e) => {+ if (affectsWorkspaceContains([...e.created, ...e.removed], projectRoots(), currentKeys())) refresh();+ }),+ onIdeEvent("excludedDirsChanged", (e) => {+ if (affectsWorkspaceContains(e.dirs, projectRoots(), currentKeys())) refresh();+ }),+ ];+ refresh();+ return () => disposers.forEach((d) => d());+}