Порівняти коміти

..
Автор SHA1 Повідомлення Дата
l0ng-ai a949a93454 fix(ci): drop an undefined Compare Directories class and a Unix-only test variable on Windows (#4132)
main's Frontend job failed in cssModules.test.ts because DirectoryCompare.tsx read styles.name, a class its CSS module never defined; the name cell now uses styles.cell only. The Windows clippy job failed on the unused temp folder in the mock_server path-spelling test; it only holds the Unix symlink, so it is created under cfg(unix) as well.
2026-11-18 13:35:11 +08:00
Mariano Dupont 16cfb63bda fix(windows): offer recovery after WebView2 browser crashes (#4055) 2026-11-18 12:03:13 +08:00
Mariano Dupontтаmarianomd 6b1d5aca50 fix(ci): resolve Windows and plugin frame failures (#4121)
Four failures of the full CI run: the JDT LS workspace marker's modification time is set explicitly (an empty write can keep the old time on Windows); the JS debugger waits for CDP to acknowledge Fetch.disable before closing the socket, so the connection isn't reset with unread replies; the Maven generated-source test compares paths as PathBuf so Windows separators compare equal; the plugin iframe test finds the document message by type and also covers a theme message arriving first.

Co-authored-by: marianomd <[email protected]>
2026-11-18 11:58:37 +08:00
Mr0Bread b5bdab0a63 fix(agents): release closed and deleted tasks' conversations (#4037)
The agents store never released a task's conversation: deleting, archiving, closing its tab or switching the docked task kept its entries, subagent conversations and changes in memory for the whole session, and the Web Content process kept growing in long sessions. A deleted task, or an archived one that isn't shown, is now dropped at once; closed or un-docked tasks stay in a cache of the 5 most recent and fetch their conversation and changes again when reopened. Change fetches that finish after a task's cache was dropped are discarded. The symbol lookup, file-existence and GitHub item caches are bounded, and a large symbol lookup answers every name of the request.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-18 11:55:57 +08:00
acaoтаamphetamlne c3e19c93d3 fix(lsp): preserve configured environment for Go module checks (#3287)
The go.mod deprecation query ran 'go list -m -u -e -json' without the language server's configured env, so GOPRIVATE, GOPROXY, GOTOOLCHAIN and GOWORK set for gopls were lost. The command now gets the server's env, with PATH still the server's search path.

Co-authored-by: amphetamlne <[email protected]>
2026-11-18 11:55:04 +08:00
l0ng-ai b33762b4c8 fix(vcs): Compare Directories copies nothing before the overwrite answer, filters nested folders, keeps name columns readable (#4120)
copy_merge without overwrite now finds the first conflict before writing anything, so declining the overwrite prompt leaves the destination untouched. A filter match below nested one-sided folders is attributed to the outermost one, the only row shown for that subtree. Name columns keep at least 96px; size and date shrink first and end in an ellipsis.

Fixes #4084
Fixes #4085
Fixes #4086
2026-11-18 11:54:13 +08:00
Muuтаmuutot 41087d074b fix(editor): fold Python & Elixir docstrings by default (#4072)
Fold by default > Documentation comments ignored docstrings written as string literals: the folding backend only emitted Comment folds for comment nodes. It now marks a multi-line Python docstring (the first statement of a module, class or function body) and an Elixir @doc / @moduledoc / @typedoc string or sigil as Comment folds. The frontend treats a comment fold as the file header only when it sits at the top of the file and starts with a comment token, so a module docstring follows the documentation toggle.

Co-authored-by: muutot <[email protected]>
2026-11-18 11:53:39 +08:00
Bert Verhelstтаbertyhell fa8dd2465a fix(vcs): the unified diff viewer shows whole added and deleted blocks as blocks (#4036)
A chunk without inner (word) fragments stored its whole block as changes, so @codemirror/merge's unified view marked every line of an added or deleted block as changed text and the block looked broken into per-line bars. Such chunks, and the coarse fallback chunks used when the comparison gives up on repetitive files, now carry no changes. Whole deleted blocks take the full deleted colour; only the old lines of a word-compared chunk keep the lighter one.

Closes #3913

Co-authored-by: bertyhell <[email protected]>
2026-11-18 11:51:41 +08:00
l0ng-ai ea965c7e2d fix(search): Windows module scopes and file URLs, and search again after a multi-line replace (#4119)
A Windows workspace module scope joined the module path with '/', so Find in Files searched nothing; it now resolves the directory like the other scopes (same fix for Markdown relative links and version catalog paths). A file:///C:/ URL typed as a query kept its leading slash and percent-escapes; it is now decoded to the drive path. After Replace with a multi-line replacement, a pattern that can match a line break, a cancelled run or fewer replacements than usages, the result list was stale; Find in Files now searches again.

Fixes #4069
Fixes #4079
Fixes #4082
2026-11-18 11:48:42 +08:00
l0ng-ai db790adf2f fix(agents): reference files of every workspace project from the composer (#4113)
In a multi-project window the composer only resolved paths against the agent task's folder and its project, so drops from another workspace project were ignored and @ completion named them wrongly. referenceOf() now resolves against the task root first, then names a file of another workspace project as <project folder>/<path> with its absolute path; paths outside the window's projects are reported instead of silently dropped. Folder references keep their trailing slash.

Fixes #4074
2026-11-18 11:34:39 +08:00
LU XIANGRUIтаwildcatDownstairs d5caebc2bb fix(run): find openideaRun on Gradle 7.0 and older when jvmargs are set (#4108)
With org.gradle.jvmargs set (project or ~/.gradle), Gradle 7.0 and older pass the command line's -D values to a build JVM only after settings load, so gradleRun.gradle read openidea.run.project as null at the top of the init script and skipped registering openideaRun ("Task 'openideaRun' not found"). The property is now read inside the allprojects action, which runs after settings. gradleBoot.gradle and gradleTests.gradle already read theirs in projectsEvaluated.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 11:09:34 +08:00
Bin 9f39cf2963 fix(editor): fold imports inside Vue script blocks (#4098)
Syntax folding for HTML-based containers (Vue, HTML, Svelte, JSP) parsed only the HTML tree, so embedded <script> blocks produced no TypeScript/JavaScript folds and their imports never folded (nor folded by default). The folds of each script region are now computed with its own language and shifted to document lines, for both the cached and uncached paths; non-JavaScript script types are left alone.

Co-authored-by: ffgenius <[email protected]>
2026-11-18 11:08:45 +08:00
LU XIANGRUIтаwildcatDownstairs e8abf8a800 fix(search): Replace All past the result limit replaces every match in scope (#4106)
Replace All sent only the listed (limit-capped) usages to the backend, and in a single file it skipped the confirmation that mentioned the limit, so matches past the 2,000 (popup) / 10,000 (Find window) limit were silently left. Once the search hit its limit, Replace All now always confirms and asks replace_in_files for all_in_scope: the backend searches the scope again without the limit on a blocking thread (project excludes applied, cancellable) and replaces every match, keeping excluded or already-replaced usages through the new ReplaceTarget.skip. Below the limit nothing changes; Replace Selected still replaces only the selection.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 11:05:54 +08:00
LU XIANGRUIтаwildcatDownstairs cd63696998 fix(search): Search Everywhere text search uses the query as typed (#4104)
SeController parsed every section's query with parseLocationQuery, so a trailing :digits (a port in http://localhost:8080, 10:30, a:1) was taken as a line and dropped from text searches; the Find in Files handoff used the parsed text too. Location parsing now applies only to sections whose results open at a line (files, classes, symbols); text, actions and endpoints, and the handoff to Find in Files, use the trimmed query.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 10:58:31 +08:00
LU XIANGRUIтаwildcatDownstairs cb52ba066d fix(search): keep Find in Files header controls inside a narrow popup (#4102)
At the minimum window size the Find/Replace in Files header was a single non-wrapping flex row with a fixed-width mask input, so the title and count wrapped and Search Context / Pin Window were clipped by the popup. Below the popup's own minimum width (a container query) the mask and buttons move to a second row; the title and count stay on one line and end in an ellipsis. An e2e test checks every search popup's header controls at 400 × 500.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 10:58:26 +08:00
LU XIANGRUIтаwildcatDownstairs 7a3f004235 fix(notifications): take down a failure balloon once a reload or server start succeeds (#4101)
A failed Maven/Gradle reload left its error balloon on screen after a later reload succeeded: syncTool notified on failure under build-sync-<tool> but never expired that key on success. A clean sync now expires it (the Notifications tool window keeps the entry). The same holds for the language-server prompts (not installed, JDK required, outdated build): a server turning ready expires them, for when the fix came from a settings page rather than the prompt's button. expireNotification leaves the state untouched when no balloon is shown.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 10:54:51 +08:00
acaoтаamphetamlne 4952a94064 chore(lsp): correlate server lifecycle and diagnostic logs (#3249)
Language-server startup, initialize and window/logMessage entries carry the server id and generation, and the initialize log reports startup_to_initialize_ms (settings, queueing, launch and initialize) even without serverInfo. Routing to a server for a file outside the project logs its root at DEBUG only. Tests characterize how an external Go file reuses the first module's server and reopens after a restart.

Co-authored-by: amphetamlne <[email protected]>
2026-11-18 10:43:35 +08:00
acaoтаamphetamlne [email protected] 49b11e59ec test(sdk): verify portable Python commands preserve fallback settings (#3433)
Saving and reloading a Python run configuration, and moving a saved bare member onto another primary project's auto-detected venv, must round-trip the whole resolved configuration (interpreter, env, PATH, module), not only the command.

Co-authored-by: amphetamlne [email protected]
2026-11-18 10:42:38 +08:00
Deng Liuтаdengliu c4674a65f3 fix(editor): treat an unset softWrap like the default (enabled) (#4090)
softWrapActive coerced an unset softWrap to false, while DEFAULT_SETTINGS.editor.softWrap and the backend EditorSettings default it to true (scoped by softWrapFiles). Editors opened before settings load, or with the field unset, skipped wrapping on *.md / *.txt / *.rst / *.adoc. An unset value now behaves like the default; an explicit false still disables wrapping.

Co-authored-by: dengliu <[email protected]>
2026-11-18 10:29:54 +08:00
Muuтаmuutot e7c2032fd1 fix(python): resolve imports from attached dependency projects (#4091)
Projects added in Project Structure > Dependencies (or picked as a workspace member's dependencies) only reached the IDE's index and navigation, so basedpyright/Pyright reported imports into them as unresolved. Their roots, plus a src folder when the dependency has a src layout, are now appended to the server's analysis.extraPaths, keeping and de-duplicating paths already configured. Container Python targets keep their own site-packages extraPaths. A malformed settings section is replaced instead of panicking.

Closes #4076

Co-authored-by: muutot <[email protected]>
2026-11-18 10:28:41 +08:00
Deng Liuтаdengliu bb827d02f9 feat(markdown): make the editor and preview split resizable (#4060)
The Markdown editor and preview split is now a SplitGroup with a draggable handle (10-90%), one persisted ratio for all Markdown files, and double-click on the handle resets to 50/50. Double-click reset lives in SplitHandle, so every split gets it. The editor re-measures CodeMirror and the preview stays anchored to the editor's top line while the divider moves; wide preview tables scroll horizontally instead of overflowing.

Co-authored-by: dengliu <[email protected]>
2026-11-18 10:21:46 +08:00
Deng Liuтаdengliu 0e29c78616 perf(settings): open Settings directly from the native menu (#4053)
Settings… and Settings for New Projects… from the native menu went through the focused project window's frontend (menu event → executeAction → window_open_settings), so a busy JS thread in that window delayed the Settings window. With Settings in a separate window, the menu handler now opens or focuses settings-<parent> in Rust. Auxiliary windows route to their project window as before; a pending cold launch or the in-window dialog mode still goes through the frontend. Auxiliary windows opened without a frame colour now get the parent's theme frame colour computed natively.

Co-authored-by: dengliu <[email protected]>
2026-11-18 10:19:06 +08:00
LU XIANGRUIтаwildcatDownstairs 7edc35e515 fix(lsp): serve files spelt differently from the project root with its framework servers (#4075)
The project root is canonicalized when a project opens (real letter case on macOS, symlinks resolved), but document paths are not. Choosing language servers and framework UI modes checked path.starts_with(project_root), so a file opened under another spelling (other letter case, a symlinked folder) looked outside the project: servers that require a root marker (Angular, ESLint/oxlint, Ruff, laravel-lsp, arduino) skipped it, and Angular templates fell back to plain HTML. ide_language::project_spelling now retries with the canonical path when a path looks outside the project; LspManager::servers_for, serves_path and LanguageRegistry::framework_ui_mode use it. URIs sent to servers keep the document's own spelling.

Closes #4061

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 10:12:06 +08:00
LU XIANGRUIтаwildcatDownstairs 7780c3fe64 fix(workbench): move status items that don't fit into an overflow popup (#4087)
At narrow window widths the right status items were clipped off the bar (the bar is overflow: hidden and right items don't shrink), so the Python interpreter picker, caret, encoding and others became unreachable. Right items that don't fit now move into a trailing "..." popup, lowest priority first, and come back when the window widens. Each item renders into a stable host element that moves between the bar and the popup, so widgets keep their state and their own popups.

Closes #4071

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 10:10:58 +08:00
l0ng-ai d98592ea7f feat(maven): add an unlinked pom.xml as a Maven project (#4088)
The Project view offers Add as Maven Project on a pom.xml that Maven doesn't load (neither linked nor a module of a linked project), and the editor shows a banner above such a file with Load Maven Project and Skip. Skip, and unlinking a project, stop the banner for that pom.xml and the folders under it. Files under build output, sources or dependency folders get no banner.
2026-11-18 10:08:39 +08:00
LU XIANGRUIтаwildcatDownstairs c69c5935f3 fix(run): detect run configurations for Maven/Gradle builds linked deeper than the folder scan (#4073)
After Add Maven Projects linked a module four levels deep, the run gutter on its main() still fell back to Java Single File. Run configuration detection only scanned build files three levels deep and ignored the builds the user linked, so the module had no maven/gradle configuration and the run producers treated the file as outside any build. detected_and_saved now passes the linked Maven POM folders and linked Gradle build folders that detection did not reach to the new ide_run::detect_builds, which reuses the existing Maven/Gradle detection (including Spring Boot applications). Folders inside a detected build stay with its reactor, and POMs linked from outside the project folder are handled too. Unlinked deep modules are unchanged.

Closes #4066

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 10:00:01 +08:00
Mr0Bread a67b094e2c refactor(agents): split the session editor into per-component modules (#3760)
SessionEditor.tsx (about 3,500 lines) is split into modules under src/features/agents/session/: the status line, composer, stream, messages, tool entries, question form, changes pane, find bar, folds, process and working rows. The declarations move unchanged apart from their exports; SessionEditor.tsx keeps the task session shell. Changes main made to the session editor after the split was prepared (#3961, #4013, #4015) are carried into the modules that now hold that code.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-18 09:54:52 +08:00
l0ng-ai 688d5f1b30 feat(vcs): open Compare Directories as an editor tab with columns per side (#4077)
Compare Directories opens as a restorable editor tab instead of a modal dialog. The table shows name, size and date for each side with a status marker between them, colours rows by status, groups files under their folder (a folder present on both sides heads its group and can be copied whole; a one-sided folder is one row), and previews the selected file's diff below; Enter or double-click opens it in its own tab. Toolbar toggles filter by status. The backend comparison now returns each side's file size and modification time.

Part of #3925
2026-11-18 09:44:01 +08:00
Bert Verhelstтаbertyhell 6ad6559f4a feat(env): load the project's direnv environment (#4049)
A trusted project with an .envrc in its root now gets its direnv environment, locally and over remote development. The IDE runs `direnv export json` in the background (cancellable, 10-minute timeout); terminals, run configurations, language servers, build tools and debuggers started in the project get what it exports, and language servers wait until it has loaded.

The environment layer was process-wide, but one desktop process holds several projects: ide_core::project_env keeps one environment per project root, and the shared spawn helpers pick it from the child's working directory (host_env / prepare from current_dir, plus the *_in variants for PTYs and PATH lookups). Restricted Mode never runs direnv, and revoking trust drops the environment.

A missing direnv gives a one-time hint, a blocked .envrc a warning to run direnv allow (the IDE never runs it), failures and timeouts an error with the end of direnv's output. Changes to .envrc, flake.nix or flake.lock offer Reload Environment, which loads direnv again too. The changed-file notice's title is now translated.

Closes #3555

Co-authored-by: bertyhell <[email protected]>
2026-11-18 09:29:59 +08:00
Bert Verhelstтаbertyhell 69d839e123 feat(plugins): read the clipboard from user-invoked commands (API 1.11) (#4047)
Plugins could write the clipboard but not read it. ui.read-clipboard() (SDK host::read_clipboard()) returns the text and a PNG image of the user's clipboard, behind a new clipboard.read capability. Only calls the user started can read: plugin commands and view actions run by the user, not event handlers, web view messages or commands chained through command-runner. The host never reads the clipboard itself: it asks the invoking window (ClipboardRequested / plugin_answer_clipboard), so remote development reads the client's clipboard, and a remote window asks the user first. Plugin API 1.11.0; components rebuilt.

Closes #3524

Co-authored-by: bertyhell <[email protected]>
2026-11-18 09:20:09 +08:00
Deng Liuтаdengliu 606a66b5dd perf(settings): batch store registrations and defer font enumeration (#4058)
Settings pages, parent action proxies and template actions registered one by one, cloning the store map and notifying subscribers per item (~1,650 action and ~172 page updates per Settings open). registerActions now disposes in one update too, and the new registerSettingsPages batches page registration and disposal; both keep later per-id overrides. Disabled font pickers no longer enumerate system fonts; enabled ones defer it to idle and load at once on interaction, and the icon-font probe waits past startup.

Co-authored-by: dengliu <[email protected]>
2026-11-18 09:10:40 +08:00
Akbar Husain 0e169cc653 feat(editor): render Zig doc comments without a grammar (#4052)
Doc comments were found by walking the CodeMirror syntax tree, so languages without a grammar (Zig) never had their /// and //! docs rendered. docComments() now scans the lines when the tree is empty, with the tree walk's markers and rules, limited to languages whose comment tokens are // (line docs) or /* (block docs) so plain text and logs stay untouched.

Co-authored-by: akbar1214 <[email protected]>
2026-11-18 09:06:55 +08:00
Mr0Bread 21314846cf fix(agents): stop the conversation leaking graphics memory into the app process (#4057)
WebKit leaves the surfaces of a scrolling view in the app process when the view's height keeps crossing 2048 CSS px, which the agent conversation does while turns fold and replies stream (~1 GB per 40 crossings). Each conversation row now paints into its own layer (will-change: transform), so the stream's scrolled contents allocate no such surfaces.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-18 09:02:24 +08:00
l0ng-ai 4fd04b93d4 fix(editor): draw rainbow indent guides at half strength (#4068)
Rainbow indent guides used text palettes (semantic highlighting, rainbow brackets) at full strength, which read as heavy lines. Guides now mix each colour 55% with transparent, keeping the hues distinct and matched to their brackets.

Fixes #4022
2026-11-18 08:59:39 +08:00
l0ng-ai 79d2b1e5c0 feat(editor): underline editor tabs of files with errors (#4067)
Editor tabs show the Project view's wavy error underline for files the problems provider marks with errors. The label gets block padding so the ellipsis clip doesn't cut the wave off.

Fixes #4027
2026-11-18 08:54:51 +08:00
l0ng-ai 5657dbd3e3 fix(color-scheme): an unticked Foreground keeps the text visible (#4065)
Unticking Foreground wrote the cleared colour, transparent, into the
attribute's colour variable, so its tokens became invisible. A cleared
foreground now falls back to the default text colour; cleared backgrounds
and effects stay transparent.

Refs #4059
2026-11-18 08:45:40 +08:00
l0ng-ai 2678698bf9 fix(agents): report a session that fails to load instead of replacing it (#4064)
When session/load failed for a task's saved session, the task silently
started a new session and stored its id over the old one, so the agent lost
the conversation without a word in the chat (OMP fails to load a session
saved with a model it cannot restore). The failure now shows in the chat and
keeps the saved session; sending again starts a new session. An
authentication failure during the load shows the sign-in error instead.

Fixes #4035
2026-11-18 08:43:12 +08:00
l0ng-ai e8d91b4615 docs: drop the memory indicator from the landing page screenshot (#4063) 2026-11-18 08:41:44 +08:00
Ray Liangтаcubelitblade c1f3debbb9 fix(terminal): use fish's hostname variable for OSC 7 (#4050)
The fish prompt hook ran the external hostname command to build the OSC 7
working-directory URL, so fish printed an error at every prompt where that
command is unavailable. It now uses fish's built-in \$hostname variable.

Closes #4046

Co-authored-by: cubelitblade <[email protected]>
2026-11-18 08:37:55 +08:00
l0ng-ai c1782f01eb docs: add a landing page and a plugin marketplace to the documentation site (#4033)
/en and /zh open a landing page: the product in the dark theme, startup and
memory numbers, the main features, featured plugins and the default keymap.
The introduction pages move to /en/introduction and /zh/introduction.

/plugins and /zh/plugins list the marketplace's plugins with search,
category filters, sorting and a details dialog. The list is a snapshot of
plugins-index.json written by `pnpm gen:plugin-catalog`.
2026-11-18 02:03:42 +08:00
Ernstjan FreriksтаEjaYF 9cfe667b6a fix(clipboard): build on Windows again after the command refactor (#4030)
#3598 moved blocking from src-tauri's commands::doc to ide_host::ops::doc,
but the Windows-only import in commands/clipboard.rs still named the old
path, so src-tauri no longer compiled on Windows. It now imports
ide_host::ops::doc::blocking like commands/db.rs and commands/perf.rs.

Co-authored-by: EjaYF <[email protected]>
2026-11-17 23:40:40 +08:00
Ernstjan FreriksтаEjaYF 318f4a2d82 feat(database): export with mysqldump and restore with mysql (#4001)
MySQL and MariaDB data sources, schemas and tables get Import/Export >
Export with 'mysqldump' and Restore with 'mysql'. ide-db builds the arguments
from typed options and runs the tool connected like the data source (TCP,
the driver's SSL flags, the SSH tunnel); the password goes in a user-only
temporary option file passed as --defaults-extra-file and removed after the
run. Restore pipes the dump into mysql's standard input.

Restore dialogs (MySQL and PostgreSQL) now check the target first: the
Database field lists the source's databases and disables Run for a missing
one, and db_dump_info (formerly db_dump_kind) reports whether an SQL dump
creates its database itself. pg_restore gains --create.

Part of #3188

Co-authored-by: EjaYF <[email protected]>
2026-11-17 23:39:50 +08:00
LU XIANGRUIтаwildcatDownstairs 31466f2834 feat(lsp): make type names in other languages' documentation signatures clickable (#4010)
Go signatures already linked their type names (#3959). For other languages
the name is looked up near the documented symbol's declaration and the
language server's definition there is the target; parameters, the symbol's
own name, inferred types and names with several definitions don't link.
Names resolve on hover, so only those that lead somewhere look like links,
and only the signature code blocks are considered (leading blocks, or the
one after the last rule for clangd). Plain names a grammar leaves untagged
get a tok-name span so they can be followed.

Refs #3874

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-17 23:29:20 +08:00
lleviathe 9f9beaa27c feat(mcp): show the callers and callees of a function with get_call_hierarchy (#4019)
The built-in MCP server had no call hierarchy, so agents fell back to text
search for callers. get_call_hierarchy returns one level of callers (default)
or callees of the function at a position through lsp_call_hierarchy, with
call sites and their line text, paging and scope like find_references; a
position inside a body means the enclosing function. ide-lsp reports the
hierarchy's root and the file of an outgoing call's sites. find_references
now shares the document guard and the cancel/timeout race with it.

Co-authored-by: lleviathe <[email protected]>
2026-11-17 23:27:25 +08:00
xiaowu0203 182285647e fix(editor): make rectangular mouse selection configurable (#4020)
The rectangular drag gestures were hard-coded, and a middle-button press
navigated immediately, which cut off a middle drag. A new keymap action,
Create Rectangular Selection on Mouse Drag (Alt+Left and Middle by default),
now decides the gesture; middle-click navigation fires on release when the
mouse did not move. Linux keeps middle-button paste unless the user binds the
middle button explicitly, and the mouse shortcut recorder accepts modified
middle clicks.

Closes #3713

Co-authored-by: xiaowu0203 <[email protected]>
2026-11-17 23:22:56 +08:00
Yann ba4bf0ce1d fix(agents): show Codex asynchronous questions (#4013)
Codex attaches non-blocking questions to completed agent messages, but the
question metadata was discarded and only the message text was shown. The
Codex shim now emits them as user_question updates (live and from history),
the timeline keeps them as Question entries that survive the turn's end and
restarts, and the existing question card answers them with Codex's stable
question ids: a running turn is steered, an idle task starts a normal turn.
Skipping does not cancel the agent; blocking permission questions keep
priority over asynchronous ones.

Co-authored-by: YannABC <[email protected]>
2026-11-17 23:19:50 +08:00
l0ng-ai 76c75b0f7f fix(plugins): deliver document-changed events to plugins (#4028)
The event queue relativized path events at enqueue time, so the delivery
filter looked up a project-relative document path, found no project and
dropped every document-changed event. Document paths now stay absolute
through filtering and are relativized to the file's own project at hand-off.
The path-events fixture subscribes document-changed to cover the flow.

Fixes #4008
2026-11-17 23:13:54 +08:00
l0ng-ai c8a91e5b0f feat(appearance): Presentation Assistant (#4026)
While on, each action the user runs shows its name and shortcut in a popup, for screencasts and demos. Toggled from View › Appearance › Presentation Assistant; Settings › Appearance › Presentation Assistant sets the popup size, duration, position and whether to also show the other platform's shortcut (macOS ⇄ Windows/Linux). Hidden actions are not shown.

Closes #3949
2026-11-17 23:01:12 +08:00
l0ng-ai a430d4ace7 fix(tools): fail and retry a stalled tool download instead of hanging (#4024)
Tool downloads used curl with only a connect timeout, so a connection that stopped delivering (a stalled proxy or mirror) left Install waiting indefinitely. Requests now fail after 30 s without data (--speed-limit 1 --speed-time 30), which curl's --retry treats as transient and retries.
2026-11-17 22:47:14 +08:00
l0ng-ai 7e5277eaa6 feat(languages): Typst with the tinymist language server (#4023)
Typst (.typ) files get syntax colouring for markup, embedded code and math, a file icon, and the tinymist language server (installable from its GitHub releases) for completion, diagnostics, navigation and the outline.

Closes #3924
2026-11-17 22:44:13 +08:00
l0ng-ai 2278cf6e8f fix(editor): don't indent C++ namespace and extern "C" contents on Enter (#4018)
Enter inside namespace x { … } or extern "C" { … } indented the new line one level, like any brace body. clang-format's built-in styles (LLVM, Google, Chromium, Mozilla, Microsoft, GNU) keep those contents at the level of the braces' line (NamespaceIndentation: None), so the editor now does too; other brace bodies keep their indentation.

Fixes #3993
2026-11-17 22:10:13 +08:00
l0ng-ai d4f6114be1 feat(settings): context menu for the deployment server list (#4017)
Right-clicking a server or server group in Settings › Build, Execution, Deployment › Deployment selects it and offers Add (Server / Server Group), Duplicate and Use as Default for a server, and Remove; the empty part of the list offers Add.

Closes #3910
2026-11-17 22:03:35 +08:00
l0ng-ai ad93e491c9 feat(settings): choose PHP include paths with a folder chooser (#4016)
+ under Settings › Languages & Frameworks › PHP › Include paths opens a folder chooser and adds the picked folder; Edit and double-click still take a typed path, and outside the desktop app + keeps adding a row to type into. Additional stubs are stub names, so that list stays typed.

Closes #3912
2026-11-17 22:00:43 +08:00
l0ng-ai 098e80dbef fix(agents): name the task's agent in the session status line (#4015)
The session status line under the composer lost the agent's icon and name when it was reduced to one quiet line; with several tasks open side by side there was no way to tell which agent answered without opening the picker. It starts with the agent's icon and name again, before the branch.

Fixes #3917
2026-11-17 21:58:00 +08:00
l0ng-ai 6ab7627fc4 feat(vcs): project conventions for Generate Commit Message with Agent (#4014)
Settings › Version Control › Commit gets a Commit Message Generation section with a multi-line field (vcs.commit.agentInstructions, global or per project). Its text is added to the agent's prompt as the conventions to follow, ahead of the style taken from recent commit subjects.

Closes #3934
2026-11-17 21:53:38 +08:00
l0ng-ai 55e778897f feat(vcs): show a stash's changed files and their diff in the Stash tab (#4012)
Stashes in the Commit tool window's Stash tab expand to the files they changed against the commit they were made on; selecting a file previews its diff (with Show Diff Preview on) and double-clicking opens it. Double-clicking a stash expands it instead of applying it; Apply / Pop / Unstash stay on the toolbar and context menu. Stash (IPC) now carries the stash commit and its base.

Closes #3968
2026-11-17 21:45:50 +08:00
l0ng-ai cc6ed6b5fd feat(editor): copy a multi-line selection's path as path:first-last (#4011)
Copy Path with Line Number (and its entry in Copy Path/Reference…) copies path:12-18 when the selection spans several lines, leaving out a last line the selection only reaches the start of; a caret or single-line selection still copies path:12.

Closes #3962
2026-11-17 21:39:11 +08:00
Vadim LazukтаInf1mum 5efd58d3af fix(workbench): move any project tab to a new window from its own arrow (#3991)
The Move Tab to New Window arrow was one bar-level button drawn inside the last tab, above its centre line, and always moved the selected tab. Every project tab now has its own arrow on its right edge, centred and revealed on hover like the close button, and the tab context menu's Move Tab to New Window works on any tab. window_group_detach takes the tab's label and selects it before detaching; without an argument (Find Action) the action still moves the selected tab.

Fixes #3954

Co-authored-by: Inf1mum <[email protected]>
2026-11-17 21:37:59 +08:00
acaoтаamphetamlne d250b351bb fix(index): report accurate scan work counts (#3229)
Index scans log what they actually did as structured fields: files discovered, metadata reused, candidates scheduled, and mutually exclusive extraction outcomes (symbols extracted, hash reused, ignored, oversized, binary, unsupported, read failed, not processed), instead of calling every metadata-stale candidate parsed. Warm-snapshot startup and fallback scans log their phases separately; cancelled scans log no completion summary. Indexing behaviour is unchanged.

Co-authored-by: amphetamlne <[email protected]>
2026-11-17 21:34:47 +08:00
Aditya Aggarwalтаaditya-786 033f049caf feat(spring): navigate from Feign client methods to controller endpoints (#3997)
Feign client methods in Java and Kotlin get a Go to Feign Endpoint gutter arrow and action, and Go to Declaration on a literal mapping path opens the matching controller methods. Matching reuses the Spring route index (HTTP method + literal path, whole {variable} segments); a literal Feign name narrows candidates to the module whose spring.application.name matches, while dynamic or missing identities and explicit url clients keep every method/path candidate in the declaration chooser.

Refs #3882

Co-authored-by: aditya-786 <[email protected]>
2026-11-17 21:30:26 +08:00
lleviathe 74157ffe54 fix(editor): highlight toml keys, dates and booleans like IntelliJ (#3981)
Adds a TOML stream parser so keys are coloured as keys wherever they stand (table headers, dotted keys, inline tables), with numbers, booleans/dates, strings and valid/invalid escapes told apart, in files, lock files and fenced code blocks.

Co-authored-by: lleviathe <[email protected]>
2026-11-17 21:27:09 +08:00
lleviathe 732e92f756 fix(editor): colour .env and properties keys like other key-value files (#3979)
Adds a properties/.env stream language wrapper so keys use the keyword colour, the first separator the operator colour and values the string colour.

Co-authored-by: lleviathe <[email protected]>
2026-11-17 21:23:53 +08:00
QтаNeverKnowsTomorrow a83bad107c fix(plugins): ask before loading a changed Java agent (#4003)
When a plugin's Java agent jar changed, the host already refused to load it until java.agent was granted again, but Settings still showed the permission as granted, so the agent silently disappeared from Run/Debug. PluginInfo now carries the agent's file name, arguments and whether its jar still matches the approved hash; Settings › Plugins warns about a changed jar and offers Approve new jar, which grants the permission again.

Co-authored-by: NeverKnowsTomorrow <[email protected]>
2026-11-17 21:20:40 +08:00
Akbar Husain 39f709def5 fix(run): debug Zig build steps via the executable config (#4002)
Debug on a detected 'zig build run' configuration said it had no debug adapter: build-step configs only run 'zig build <step>'. Steps that run an executable (addRunArtifact in build.zig) now link to that executable's config, and Debug delegates to it — running its before-launch build and keeping the clicked step as the session's origin.

Refs #3260

Co-authored-by: akbar1214 <[email protected]>
2026-11-17 21:17:05 +08:00
pravdomil ea6638b05e fix(editor): keep scroll inertia out of ⌘/Ctrl+wheel font zoom (#3985)
WebViews don't expose macOS momentum phases, so a trackpad scroll still coasting when ⌘ was pressed zoomed the text, and the inertia after a ⌘ swipe kept zooming. Wheel events less than 150 ms apart now count as one gesture: only a gesture that started with ⌘/Ctrl zooms, and once its deltas shrink four events in a row the rest is inertia. All ⌘/Ctrl+wheel font-zoom surfaces use it (editor, terminal, agent chat, Markdown preview, plugin and services log editors).

Co-authored-by: pravdomil <[email protected]>
2026-11-17 21:15:20 +08:00
TarasтаTarasMK a91421c6e0 fix(docker): list containers without asking the daemon for their sizes (#3976)
Containers were listed with --format '{{json .}}', which includes Size, so the daemon computed every container's writable layer and a busy daemon exceeded the 20 s listing timeout ('docker did not respond in time', no Compose groups). The listing now uses a template with only the fields the parser reads.

Fixes #3975

Co-authored-by: TarasMK <[email protected]>
2026-11-17 21:13:09 +08:00
l0ng-ai 973f0a18a8 fix(vue): don't indent code in top-level <script> and <style> blocks (#4009)
The HTML base indented every element's children, so Enter in <script setup> indented the new line. Like WebStorm's Vue code style, only the top-level <template>'s children are indented; code in top-level <script> and <style> blocks starts at the margin.

Fixes #3982
2026-11-17 21:11:13 +08:00
Vadim LazukтаInf1mum fb64f0cd26 fix(vcs): say whether blocked checkout would remove or overwrite the untracked files (#4005)
When git refused a checkout because of untracked files, the notification always said they would be overwritten; git's own reason (removed vs overwritten) is now carried on CheckoutOutcome::UntrackedFiles and the notification uses git's wording for each case.

Fixes #3980

Co-authored-by: Inf1mum <[email protected]>
2026-11-17 21:07:39 +08:00
l0ng-ai 34f2e18ff1 fix(macos): keep full screen when Escape goes unhandled (#4006)
Escape the page leaves unhandled goes back from WebKit as the web view's doCommandBySelector:(cancelOperation:), run through NSView's own implementation, which leaves full screen directly; the window-level cancelOperation: hook from #3134 was never reached and is removed. In macOS full screen the workbench now marks Escape handled after every key handler has seen it (also when one stops it); Ctrl+Cmd+F leaves full screen.

Refs #3970, #3104
2026-11-17 20:58:44 +08:00
l0ng-ai 83a949ffe9 fix(debugger): keep an expanded value hint open (#4004)
Expanding an object in the debugger's value hint grew it into a variables tree that no longer fit above the line, so the tooltip moved below it, away from the mouse, and the hover tooltip closed as soon as the mouse moved towards it. An expanded hover hint is now shown pinned at the expression until Escape, a click in the editor, an edit or the next step; hints shown with a timeout (selection, quick evaluate, inline values) are kept once clicked or focused.

Refs #3970
2026-11-17 20:39:19 +08:00
l0ng-ai af8bd1afcd fix(debugger): debug Python with a Windows venv interpreter given by its path (#3999)
debugpyLaunch split the run configuration's command only at '/', so a Windows venv interpreter path (C:\...\.venv\Scripts\python.exe) fell back to a bare python from PATH and was passed as the module to run; when that python could not start, debugpy's launcher never connected ("Timed out waiting for launcher to connect"). Command names now split at both separators, and a venv tool given by a backslash path debugs with the python.exe next to it.

Fixes #3907
2026-11-17 20:29:12 +08:00
l0ng-ai ce12f68613 fix(hierarchy): load library types' levels from their language server (#3998)
The type hierarchy's withDocument opened every node from disk, so library types (jdt:// URIs) failed with os error 2: look-ahead loads failed silently, leaving expand arrows on every JDK type, and expanding one showed "failed to load". Library URIs now open as virtual documents.

Fixes #3409
2026-11-17 20:24:37 +08:00
543 змінених файлів з 22083 додано та 4831 видалено

No files matched your search

+1
Переглянути файл
@@ -9,6 +9,7 @@
"dist",
"target",
"src/bindings.ts",
"docs/snippets/plugin-catalog.jsx",
"evals/*/golden",
"src/editor/core/cm/angular/parser*.ts",
"src/editor/core/cm/jsp/parser*.ts",
Створено
+2
Переглянути файл
@@ -4589,6 +4589,7 @@ version = "0.1.47"
dependencies = [
"blake3",
"criterion",
"dunce",
"ide-core",
"ide-extension",
"ide-text",
@@ -6733,6 +6734,7 @@ dependencies = [
"tracing",
"tracing-appender",
"tracing-subscriber",
"webview2-com",
"windows",
"windows-sys 0.61.2",
]
+80
Переглянути файл
@@ -0,0 +1,80 @@
//! Codex's asynchronous questions are answered by a user message, not a permission response.
use crate::AgentQuestion;
use ide_core::{IdeError, IdeResult};
use serde_json::json;
use std::collections::BTreeMap;
/// The wire reply and its readable record. Question ids, not wording, associate each answer.
pub(crate) fn reply(questions: &[AgentQuestion], answers: &str) -> IdeResult<(String, String)> {
let answers: BTreeMap<String, Vec<String>> =
serde_json::from_str(answers).map_err(|_| IdeError::invalid("invalid question answers"))?;
if questions.is_empty() || answers.len() != questions.len() {
return Err(IdeError::invalid("answer every question"));
}
let mut replies = Vec::new();
let mut record = Vec::new();
for question in questions {
let key = question.answer_key.as_deref().ok_or_else(|| IdeError::invalid("missing question id"))?;
let values = answers.get(key).ok_or_else(|| IdeError::invalid("missing question answer"))?;
if values.is_empty()
|| (!question.multi_select && values.len() != 1)
|| values.iter().any(|v| v.trim().is_empty())
{
return Err(IdeError::invalid("empty or invalid question answer"));
}
let answer = values.iter().map(|v| v.trim()).collect::<Vec<_>>().join(", ");
let mut title = question.question.clone();
let mut end = title.len().min(512);
while !title.is_char_boundary(end) {
end -= 1;
}
title.truncate(end);
title = title.replace(['\n', '\r'], " ");
replies.push(json!({ "questionItemId": key, "question": title, "answer": answer }));
record.push(format!("{}: {}", question.question, answer));
}
Ok((
format!("<send_user_message_question_reply>\n{}\n</send_user_message_question_reply>", json!(replies)),
record.join("\n"),
))
}
#[cfg(test)]
mod tests {
use super::*;
fn question(key: &str) -> AgentQuestion {
AgentQuestion {
answer_key: Some(key.into()),
header: String::new(),
question: "Which?".into(),
multi_select: false,
options: Vec::new(),
}
}
#[test]
fn identical_wording_keeps_answers_associated_with_ids() {
let (wire, record) =
reply(&[question("first"), question("second")], r#"{"first":[" One "],"second":["Two"]}"#).unwrap();
let body = wire
.strip_prefix("<send_user_message_question_reply>\n")
.unwrap()
.strip_suffix("\n</send_user_message_question_reply>")
.unwrap();
let replies: serde_json::Value = serde_json::from_str(body).unwrap();
assert_eq!(replies[0], json!({"questionItemId":"first","question":"Which?","answer":"One"}));
assert_eq!(replies[1]["answer"], "Two");
assert_eq!(record, "Which?: One\nWhich?: Two");
}
#[test]
fn malformed_missing_and_empty_answers_are_rejected() {
for answers in
["no", "{}", r#"{"other":["One"]}"#, r#"{"first":[]}"#, r#"{"first":[" "]}"#, r#"{"first":["One","Two"]}"#]
{
assert!(reply(&[question("first")], answers).is_err(), "{answers}");
}
}
}
+75 -3
Переглянути файл
@@ -8,6 +8,7 @@
//! next prompt when the agent supports `session/load`.
mod acp;
mod async_questions;
mod catalogs;
mod config;
mod conversation;
@@ -415,11 +416,15 @@ struct Task {
live: Mutex<Option<Live>>,
/// Serializes starting the agent.
connecting: tokio::sync::Mutex<()>,
/// Serializes replies from multiple windows to the same async question.
answering_questions: tokio::sync::Mutex<()>,
/// Unanswered permission requests: where to send the chosen option id.
permissions: Mutex<HashMap<u32, std::sync::mpsc::Sender<Option<String>>>>,
next_permission: AtomicU32,
/// Set while `session/load` replays history we already have.
replaying: AtomicBool,
/// The saved session failed to load and the user was told: the next start opens a new one.
start_fresh: AtomicBool,
/// The current turn is being cancelled to send the first queued message right away.
send_now: AtomicBool,
/// The user stopped the current turn. A stop that reaches the agent before it took the
@@ -1409,6 +1414,53 @@ impl AgentManager {
}
}
/// Replies to a non-blocking question without interrupting the agent's current turn.
pub async fn answer_question(&self, id: &str, question: &str, answer: Option<String>) -> IdeResult<()> {
let task = self.task(id)?;
let _answering = task.answering_questions.lock().await;
let questions = {
let s = task.state.lock();
s.conversation
.main
.entries
.iter()
.find_map(|entry| match entry {
AgentEntry::Question { id, questions, chosen: None, .. } if id == question => {
Some(questions.clone())
}
_ => None,
})
.ok_or_else(|| IdeError::not_found("the question was already answered"))?
};
let chosen = match answer {
None => "Skipped".to_owned(),
Some(answer) => {
let (text, record) = async_questions::reply(&questions, &answer)?;
let prompt = AgentPrompt { text, files: Vec::new(), images: Vec::new() };
if let Err(prompt) = task.steer(prompt).await {
if task.state.lock().busy {
return Err(IdeError::unavailable("the reply could not join the running turn; try again"));
}
self.prompt(id, prompt, false).await?;
}
record
}
};
let changed = {
let mut s = task.state.lock();
s.conversation.main.entries.iter_mut().enumerate().find_map(|(index, entry)| match entry {
AgentEntry::Question { id, chosen: current, .. } if id == question => {
*current = Some(chosen.clone());
Some((None, index))
}
_ => None,
})
};
task.mark_dirty(changed);
task.persist();
Ok(())
}
/// Stops the agent and moves the task to Archived; its worktree stays.
pub fn archive(&self, id: &str) -> IdeResult<()> {
let task = self.task(id)?;
@@ -1707,9 +1759,11 @@ impl Task {
}),
live: Mutex::new(None),
connecting: tokio::sync::Mutex::new(()),
answering_questions: tokio::sync::Mutex::new(()),
permissions: Mutex::new(HashMap::new()),
next_permission: AtomicU32::new(1),
replaying: AtomicBool::new(false),
start_fresh: AtomicBool::new(false),
send_now: AtomicBool::new(false),
cancel_pending: AtomicBool::new(false),
turn_started: AtomicBool::new(false),
@@ -2318,7 +2372,8 @@ impl Task {
let mut tried_auth = false;
let mut session = None;
if let (Some(id), true) = (saved, can_load) {
let start_fresh = self.start_fresh.load(Ordering::Acquire);
if let (Some(id), true, false) = (saved, can_load, start_fresh) {
self.replaying.store(true, Ordering::Release);
let mut params = session_params(&cwd_s, &mcp_servers);
params["sessionId"] = json!(&id);
@@ -2327,7 +2382,23 @@ impl Task {
self.replaying.store(false, Ordering::Release);
match loaded {
Ok(v) => session = Some((id, v)),
Err(e) => tracing::info!("agent task {}: session/load failed, starting a new session: {e}", self.id),
// Not silently: a new session would lose the conversation and replace the saved id.
Err(e) => {
tracing::info!("agent task {}: session/load failed: {e}", self.id);
if let Some(message) = self.sign_in_error(&e, Some(&sign_in_message)) {
return Err(SessionOpenError { message, allow_acp_fallback: false });
}
self.start_fresh.store(true, Ordering::Release);
return Err(SessionOpenError {
message: format!(
"Couldn't reopen this conversation's {} session: {}\n\nSend the message again to \
continue in a new session. The agent won't see the earlier conversation.",
spec.name,
self.describe(e)
),
allow_acp_fallback: false,
});
}
}
}
let resumed = session.is_some();
@@ -2432,6 +2503,7 @@ impl Task {
s.task.config = options;
s.task.capabilities = capabilities;
s.session_id = Some(session_id.clone());
self.start_fresh.store(false, Ordering::Release);
// The (re)started process runs nothing yet: whatever it reports next is all of it.
s.background_tasks = Vec::new();
s.task.background.clear();
@@ -2655,7 +2727,7 @@ impl Task {
let applied = self.state.lock().conversation.apply(session, update, now_ms());
self.mark_dirty(applied);
// A subagent can start or finish after the turn that started it: saved right away.
if kind == "subagent_update" {
if matches!(kind, "subagent_update" | "user_question") {
self.persist();
}
}
+8
Переглянути файл
@@ -469,6 +469,14 @@ pub enum AgentEntry {
Agent {
text: String,
},
/// A question that can be answered while the agent keeps working, or after the turn ends.
Question {
id: String,
title: String,
questions: Vec<AgentQuestion>,
/// The submitted answers, or `Skipped`; `None` while unanswered.
chosen: Option<String>,
},
Thought {
text: String,
},
+5
Переглянути файл
@@ -1028,6 +1028,11 @@ impl CodexShim {
}
Some(t.chunk(kind, &id, &text))
});
if ty == "agentMessage"
&& let Some(update) = translate::question_update(item)
{
self.emit(thread, update);
}
}
"subAgentActivity" => {
let child = item.get("agentThreadId").and_then(Value::as_str).unwrap_or_default();
+50
Переглянути файл
@@ -473,6 +473,56 @@ fn history_replays_turns() {
assert_eq!(updates[4]["status"], "completed");
}
#[test]
fn history_preserves_async_questions_with_stable_answer_ids() {
let updates = history(
&json!({"turns": [{"items": [{
"type": "agentMessage", "id": "call-1", "text": "Which?",
"questions": [{"title": "Which?", "options": ["One", "Two"]}, {"title": "Why?"}]
}]}]}),
None,
);
let asked = updates.iter().find(|u| u["sessionUpdate"] == "user_question").expect("question update");
assert_eq!(asked["id"], "call-1");
assert_eq!(asked["questions"][0]["answerKey"], r#"["request_user_input_async","call-1",0]"#);
assert_eq!(asked["questions"][0]["options"][1]["label"], "Two");
assert_eq!(asked["questions"][1]["options"], json!([]));
}
#[tokio::test]
async fn completing_a_streamed_message_still_delivers_its_async_questions() {
let shim = Arc::new(CodexShim {
runtime: tokio::runtime::Handle::current(),
codex: OnceLock::new(),
client: OnceLock::new(),
state: Mutex::default(),
models: tokio::sync::Mutex::new(None),
skills: tokio::sync::Mutex::new(()),
});
shim.state.lock().threads.insert("thread".into(), Thread::default());
let client = Arc::new(Client::default());
let peer = crate::native::serve(shim.clone(), client.clone());
shim.text("thread", &json!({"itemId":"call-1","delta":"Which?"}), "agent_message_chunk", false);
shim.item(
"thread",
&json!({"type":"agentMessage","id":"call-1","text":"Which?",
"questions":[{"title":"Which?","options":["One","Two"]}]}),
true,
);
tokio::time::timeout(Duration::from_secs(2), async {
while client.of("thread").len() < 2 {
tokio::time::sleep(Duration::from_millis(5)).await;
}
})
.await
.unwrap();
assert_eq!(client.text("thread", "agent_message_chunk"), "Which?");
assert!(client.of("thread").iter().any(|u| u["sessionUpdate"] == "user_question"));
assert!(client.asked.lock().is_empty(), "an asynchronous question must not block on a permission response");
peer.kill();
shim.client.get().unwrap().kill();
}
// ---- Transcripts ---------------------------------------------------------------------
/// The ACP client: records updates and answers permission requests in order.
+31
Переглянути файл
@@ -871,6 +871,7 @@ pub(super) fn history(thread: &Value, cwd: Option<&str>) -> Vec<Value> {
if !text.is_empty() {
out.push(chunk("agent_message_chunk", text));
}
out.extend(question_update(item));
}
Some("reasoning") => {
let text = reasoning_text(item);
@@ -890,6 +891,36 @@ pub(super) fn history(thread: &Value, cwd: Option<&str>) -> Vec<Value> {
out
}
/// Structured async questions accompany a completed message, even when its text streamed already.
pub(super) fn question_update(item: &Value) -> Option<Value> {
let id = item.get("id")?.as_str().filter(|id| !id.is_empty())?;
let questions: Vec<Value> = item
.get("questions")?
.as_array()?
.iter()
.enumerate()
.filter_map(|(index, q)| {
let title = q.get("title")?.as_str().filter(|title| !title.trim().is_empty())?;
let options: Vec<Value> = q
.get("options")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(Value::as_str)
.filter(|label| !label.trim().is_empty())
.map(|label| json!({ "label": label, "description": "" }))
.collect();
Some(json!({ "answerKey": json!(["request_user_input_async", id, index]).to_string(),
"question": title, "header": "", "multiSelect": false, "options": options }))
})
.collect();
if questions.is_empty() {
return None;
}
Some(json!({ "sessionUpdate": "user_question", "id": id,
"title": questions[0]["question"], "questions": questions }))
}
/// A reasoning item's summary (or, without one, its raw text).
pub(super) fn reasoning_text(item: &Value) -> String {
let parts = |k: &str| -> Vec<String> {
+126 -2
Переглянути файл
@@ -39,6 +39,8 @@ struct FakeAgent {
authenticate_method: Option<String>,
authenticated: AtomicBool,
request_error: Option<(i64, String)>,
/// `session/load` fails with this, as OMP does for a session whose model it can't restore.
load_error: Option<(i64, String)>,
auth_methods: Vec<Value>,
/// Hold the late mode reply until the prompt's permission request is already waiting.
hold_late_mode: bool,
@@ -212,6 +214,7 @@ impl Handler for FakeAgent {
let outcome = if text == "too late" { "promptRequired" } else { "injected" };
Ok(json!({"outcome": outcome, "queue": "steering"}))
}
"session/load" if self.load_error.is_some() => Err(self.load_error.clone().unwrap()),
"session/load" => {
self.say(&session, "replayed history");
Ok(json!({}))
@@ -245,6 +248,10 @@ impl Handler for FakeAgent {
}
"session/prompt" => {
let text = params.pointer("/prompt/0/text").and_then(Value::as_str).unwrap_or_default().to_owned();
if text.starts_with("<send_user_message_question_reply>") {
self.say(&session, "answer received");
return Ok(json!({"stopReason": "end_turn"}));
}
if text == "again" {
self.say(&session, "second turn");
return Ok(json!({"stopReason": "end_turn"}));
@@ -866,7 +873,7 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
["session/load", "authenticate", "authenticate github_oauth", "session/load", "session/prompt"],
);
// If `authenticate` fails during `session/load`, fallback to `session/new` does not try it again.
// If `authenticate` fails during `session/load`, the sign-in error stands: no new session replaces it.
mgr2.shutdown();
let agent3 = Arc::new(FakeAgent {
auth_on_load: true,
@@ -885,7 +892,7 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
.iter()
.filter(|c| c.starts_with("session/") || c.starts_with("authenticate"))
.collect::<Vec<_>>(),
["session/load", "authenticate", "session/new"],
["session/load", "authenticate"],
);
mgr3.shutdown();
}
@@ -1150,10 +1157,127 @@ async fn a_task_runs_asks_for_permission_and_survives_a_restart() {
assert!(calls.contains(&"session/set_mode \"code\"".to_owned()), "{calls:?}");
}
#[tokio::test(flavor = "multi_thread")]
async fn a_session_that_fails_to_load_is_reported_and_replaced_only_when_sent_again() {
let tmp = tempfile::tempdir().unwrap();
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let saved = mgr.task(&task.id).unwrap().state.lock().session_id.clone().expect("a session");
mgr.shutdown();
// OMP: "Could not restore model …" for a session saved with a model it can't restore.
let agent = Arc::new(FakeAgent {
load_error: Some((codes::INTERNAL_ERROR, "Could not restore model x".into())),
..Default::default()
});
let mgr = manager(tmp.path(), agent.clone());
mgr.prompt(&task.id, text("again"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Failed).await;
let calls = |agent: &FakeAgent| -> Vec<String> {
agent.calls.lock().iter().filter(|c| c.starts_with("session/")).cloned().collect()
};
assert_eq!(calls(&agent), ["session/load"], "no new session behind the user's back");
let handle = mgr.task(&task.id).unwrap();
assert_eq!(handle.state.lock().session_id.as_deref(), Some(saved.as_str()));
assert!(mgr.entries(&task.id, None).unwrap().iter().any(|e| matches!(e,
AgentEntry::Error { message } if message.contains("Could not restore model x") && message.contains("Send the message again"))));
// Sending again is the user's choice to continue without the earlier conversation.
mgr.prompt(&task.id, text("again"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
assert_eq!(calls(&agent), ["session/load", "session/new", "session/prompt"]);
}
fn text(t: &str) -> AgentPrompt {
AgentPrompt { text: t.into(), ..AgentPrompt::default() }
}
fn asynchronous_question() -> Value {
json!({"sessionUpdate":"user_question","id":"call-1","title":"Which?",
"questions":[{"answerKey":"q1","question":"Which?","options":[]}]})
}
#[tokio::test(flavor = "multi_thread")]
async fn async_question_answers_join_the_turn_and_skipping_does_not_cancel_it() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent { session_steering: true, ..Default::default() });
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("wait"),
provider: "claude".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Running).await;
let handle = mgr.task(&task.id).unwrap();
handle.on_update(Some("s1"), &asynchronous_question());
assert!(mgr.answer_question(&task.id, "call-1", Some("{}".into())).await.is_err());
handle.live.lock().as_mut().unwrap().capabilities.steer = false;
assert!(mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.is_err());
assert!(handle.state.lock().task.queue.is_empty());
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
handle.live.lock().as_mut().unwrap().capabilities.steer = true;
mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.unwrap();
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
assert!(
agent.calls.lock().iter().any(|call| call.starts_with("_session/steering ") && call.contains("questionItemId"))
);
assert!(!agent.calls.lock().iter().any(|call| call == "session/cancel"));
assert!(mgr.answer_question(&task.id, "call-1", None).await.is_err());
let mut question = asynchronous_question();
question["id"] = json!("call-2");
handle.on_update(Some("s1"), &question);
mgr.answer_question(&task.id, "call-2", None).await.unwrap();
assert!(
matches!(mgr.entries(&task.id, None).unwrap().last(), Some(AgentEntry::Question { chosen: Some(chosen), .. }) if chosen == "Skipped")
);
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
mgr.cancel(&task.id, None).unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
}
#[tokio::test(flavor = "multi_thread")]
async fn async_questions_can_be_answered_after_the_turn_ends() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
mgr.task(&task.id).unwrap().on_update(Some("s1"), &asynchronous_question());
mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
assert!(
mgr.entries(&task.id, None)
.unwrap()
.iter()
.any(|entry| matches!(entry, AgentEntry::Question { chosen: Some(answer), .. } if answer == "Which?: One"))
);
let entries = mgr.entries(&task.id, None).unwrap();
assert!(
entries.iter().any(|entry| matches!(entry, AgentEntry::User { text, .. } if text.contains("questionItemId")))
);
}
#[tokio::test(flavor = "multi_thread")]
async fn steers_through_session_steering() {
let tmp = tempfile::tempdir().unwrap();
+36
Переглянути файл
@@ -54,6 +54,23 @@ impl Timeline {
let mut out = Applied::default();
let kind = update.get("sessionUpdate").and_then(Value::as_str).unwrap_or_default();
match kind {
"user_question" => {
let id = str_field(update, "id");
let Ok(questions) = serde_json::from_value::<Vec<crate::model::AgentQuestion>>(
update.get("questions").cloned().unwrap_or(Value::Null),
) else {
return out;
};
if id.is_empty()
|| questions.is_empty()
|| self.entries.iter().any(|e| matches!(e, AgentEntry::Question { id: known, .. } if known == &id))
{
return out;
}
let index =
self.push(AgentEntry::Question { id, title: str_field(update, "title"), questions, chosen: None });
out.changed.push(index);
}
"agent_message_chunk" | "agent_thought_chunk" => {
let Some(text) = content_text(update.get("content")) else { return out };
out.changed.push(self.append_text(kind == "agent_thought_chunk", &text));
@@ -388,6 +405,25 @@ mod tests {
use super::*;
use serde_json::json;
#[test]
fn asynchronous_questions_survive_turn_end_restart_and_duplicate_notifications() {
let mut t = Timeline::default();
let update = json!({"sessionUpdate":"user_question","id":"call-1","title":"Which?",
"questions":[{"answerKey":"q1","question":"Which?","options":[]}]});
assert_eq!(t.apply(&update).changed, vec![0]);
assert!(t.end_turn(None).is_empty());
assert!(matches!(&t.entries[0], AgentEntry::Question { chosen: None, .. }));
let saved = serde_json::to_string(&t.entries).unwrap();
let mut t = Timeline::from_entries(serde_json::from_str(&saved).unwrap());
assert!(t.apply(&update).changed.is_empty());
assert_eq!(t.entries.len(), 1);
if let AgentEntry::Question { chosen, .. } = &mut t.entries[0] {
*chosen = Some("One".into());
}
assert!(t.apply(&update).changed.is_empty());
assert!(matches!(&t.entries[0], AgentEntry::Question { chosen: Some(answer), .. } if answer == "One"));
}
#[test]
fn chunks_merge_into_one_message_until_another_entry_comes() {
let mut t = Timeline::default();
+3 -3
Переглянути файл
@@ -120,7 +120,7 @@ fn collect(
break;
}
}
let program = process::program_path(&step.program, &step.env);
let program = process::program_path(&step.program, &step.env, &step.cwd);
inputs.push(program.clone());
// Maven installed via a symlink still reads conf from its distribution.
if let Ok(program) = dunce::canonicalize(program)
@@ -131,7 +131,7 @@ fn collect(
}
}
if !environment.contains_key("JAVA_HOME") {
let java = process::program_path(if cfg!(windows) { "java.exe" } else { "java" }, &step.env);
let java = process::program_path(if cfg!(windows) { "java.exe" } else { "java" }, &step.env, &step.cwd);
inputs.push(java.clone());
if let Ok(java) = dunce::canonicalize(java)
&& let Some(home) = java.parent().and_then(Path::parent)
@@ -171,7 +171,7 @@ fn collect(
let steps = plan
.steps
.iter()
.map(|s| (process::program_path(&s.program, &s.env), s.args.clone(), s.cwd.clone(), s.env.clone()))
.map(|s| (process::program_path(&s.program, &s.env, &s.cwd), s.args.clone(), s.cwd.clone(), s.env.clone()))
.collect();
// Profiles and plugins can read arbitrary environment variables. Keep a signature
// of the inherited environment without persisting unrelated credentials.
+5 -4
Переглянути файл
@@ -25,8 +25,9 @@ pub(crate) struct Output {
/// `program` as spawnable: a bare name (`mvn`, `mvn.cmd`) resolves on the IDE's
/// search path — the login shell's `PATH` plus version-manager shims — since the
/// app's own `PATH` can be minimal and `Command` would not see `mvn` there.
pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>) -> std::path::PathBuf {
/// app's own `PATH` can be minimal and `Command` would not see `mvn` there. The `PATH`
/// of the project holding `cwd` (its direnv `.envrc`) comes first.
pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>, cwd: &Path) -> std::path::PathBuf {
let path = std::path::Path::new(program);
if !path.is_relative() || path.components().count() > 1 {
return path.to_path_buf();
@@ -35,7 +36,7 @@ pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>) -> std
.iter()
.find(|(k, _)| k.eq_ignore_ascii_case("PATH"))
.map(|(_, v)| std::ffi::OsString::from(v))
.unwrap_or_else(ide_core::tool_path::search_path);
.unwrap_or_else(|| ide_core::tool_path::search_path_in(cwd));
ide_core::process::find_executable(program, &search).unwrap_or_else(|| path.to_path_buf())
}
@@ -65,7 +66,7 @@ pub(crate) fn run_with_env(
// Output is read as UTF-8: JVMs on Windows are told to write it (see `ide_core::output_encoding`).
let encoding =
ide_core::output_encoding::fix(program, args, env, |k| std::env::var(k).ok(), "UTF-8", cfg!(windows));
let program = program_path(program, env);
let program = program_path(program, env, cwd);
let mut command = Command::new(&program);
command.args(args).current_dir(cwd).envs(env).envs(encoding.env.iter().map(|(k, v)| (k, v))).stdin(Stdio::null());
command.stdout(Stdio::piped()).stderr(Stdio::piped());
+20
Переглянути файл
@@ -47,6 +47,12 @@ pub enum IdeEvent {
root: crate::IpcPath,
trusted: bool,
},
/// The project's direnv environment (`.envrc`) could not be loaded, or a file it is read
/// from changed and it can be reloaded.
Direnv {
root: crate::IpcPath,
status: DirenvStatus,
},
/// Files or directories changed on disk (after debouncing, ignore rules applied).
FsChanged {
created: Vec<crate::IpcPath>,
@@ -228,6 +234,20 @@ pub enum AskpassKind {
Confirm,
}
/// See [`IdeEvent::Direnv`].
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum DirenvStatus {
/// `direnv` is not installed (on the search path).
NotInstalled,
/// direnv refuses the `.envrc` until the user approves it with `direnv allow`.
Blocked,
/// `direnv export` failed or took too long: what it printed last.
Failed { message: String },
/// `.envrc`, `flake.nix` or `flake.lock` (a file name in the project root) changed.
Changed { file: String },
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum ServerStatus {
+1
Переглянути файл
@@ -19,6 +19,7 @@ pub mod output_encoding;
pub mod platform;
pub mod process;
pub mod project_dir;
pub mod project_env;
pub mod project_roots;
pub mod proxy_settings;
pub mod real_path;
+95 -12
Переглянути файл
@@ -1,6 +1,7 @@
//! Child-process helpers shared by every crate that spawns tools.
use std::ffi::{OsStr, OsString};
use std::path::Path;
#[cfg(windows)]
use std::process::Stdio;
use std::process::{Child, Command};
@@ -18,7 +19,8 @@ pub const CREATE_NO_WINDOW: u32 = 0x0800_0000;
/// console child flashes a `cmd` window.
/// - Linux AppImage, reloaded and project variables: see [`host_env`].
///
/// Variables the call site has already set are kept; call it before `env_clear`.
/// Variables the call site has already set are kept; call it before `env_clear` and after
/// `current_dir`, which picks the project environment.
pub fn prepare(cmd: &mut Command) -> &mut Command {
#[cfg(windows)]
{
@@ -516,10 +518,13 @@ mod windows_job {
/// those of a manual HTTP proxy ([`crate::proxy_settings::ProxySettings::child_env`]),
/// and the login shell's variables this process lacks ([`shell_env`]: an app started from
/// Finder/Dock doesn't have what rc files export, such as `GOPATH`, `JAVA_HOME` or
/// `MAVEN_OPTS`). Variables the call site has already set are kept.
/// `MAVEN_OPTS`). A child whose `current_dir` is inside a project also gets the project's
/// environment ([`crate::project_env`]), so set it first. Variables the call site has
/// already set are kept.
pub fn host_env(cmd: &mut Command) -> &mut Command {
let fixes = child_env_changes();
let shell: Vec<_> = shell_env().collect();
let dir = cmd.get_current_dir().map(Path::to_path_buf);
let fixes = child_env_changes(dir.as_deref());
let shell: Vec<_> = shell_env_for(dir.as_deref()).collect();
if fixes.is_empty() && shell.is_empty() {
return cmd;
}
@@ -540,22 +545,40 @@ pub fn host_env(cmd: &mut Command) -> &mut Command {
/// that are not a `std::process::Command` (a PTY `CommandBuilder`). Apply before the call
/// site's own variables. Empty outside an AppImage without an overlay.
pub fn host_env_fixes() -> Vec<(OsString, Option<OsString>)> {
child_env_changes()
child_env_changes(None)
}
/// [`host_env_fixes`] for a child started in `dir`, the environment of the project holding it included.
pub fn host_env_fixes_in(dir: &Path) -> Vec<(OsString, Option<OsString>)> {
child_env_changes(Some(dir))
}
/// This process's environment as a child should inherit it (see [`host_env`]), for call
/// sites that build a child's environment from the IDE's own instead of inheriting it.
pub fn host_vars() -> impl Iterator<Item = (OsString, OsString)> {
apply_changes(std::env::vars_os().collect(), &child_env_changes()).into_iter()
apply_changes(std::env::vars_os().collect(), &child_env_changes(None)).into_iter()
}
/// [`host_vars`] for a child started in `dir`.
pub fn host_vars_in(dir: &Path) -> impl Iterator<Item = (OsString, OsString)> {
apply_changes(std::env::vars_os().collect(), &child_env_changes(Some(dir))).into_iter()
}
/// [`std::env::var_os`] as a child should see it (see [`host_env`]), the login shell's value
/// included when this process lacks the variable.
pub fn host_var_os(key: impl AsRef<OsStr>) -> Option<OsString> {
let key = key.as_ref();
match child_env_changes().into_iter().find(|(k, _)| k == key) {
host_var_os_for(None, key.as_ref())
}
/// [`host_var_os`] for a child started in `dir`.
pub fn host_var_os_in(dir: &Path, key: impl AsRef<OsStr>) -> Option<OsString> {
host_var_os_for(Some(dir), key.as_ref())
}
fn host_var_os_for(dir: Option<&Path>, key: &OsStr) -> Option<OsString> {
match child_env_changes(dir).into_iter().find(|(k, _)| k == key) {
Some((_, fixed)) => fixed,
None => std::env::var_os(key).or_else(|| shell_env().find(|(k, _)| k == key).map(|(_, v)| v)),
None => std::env::var_os(key).or_else(|| shell_env_for(dir).find(|(k, _)| k == key).map(|(_, v)| v)),
}
}
@@ -578,8 +601,9 @@ fn apply_changes(
vars
}
/// The AppImage fixes, the overlay, then the manual proxy's (a later one wins); one entry per name.
fn child_env_changes() -> Vec<(OsString, Option<OsString>)> {
/// The AppImage fixes, the overlay, the manual proxy's, then those of the project holding
/// `dir` (a later one wins); one entry per name.
fn child_env_changes(dir: Option<&Path>) -> Vec<(OsString, Option<OsString>)> {
let mut changes = appimage_fixes();
let overlay = env_overlay();
changes.retain(|(k, _)| !overlay.iter().any(|(o, _)| o == k));
@@ -588,6 +612,11 @@ fn child_env_changes() -> Vec<(OsString, Option<OsString>)> {
let proxy = crate::proxy_settings::proxy().child_env();
changes.retain(|(k, _)| !proxy.iter().any(|(p, _)| p == k));
changes.extend(proxy);
if let Some(dir) = dir {
let project = crate::project_env::for_dir(dir);
changes.retain(|(k, _)| !project.iter().any(|(p, _)| p == k));
changes.extend(project.iter().cloned());
}
changes
}
@@ -667,11 +696,26 @@ pub fn login_env() -> Option<Vars> {
/// Apply before a call site's own variables so those win. Empty until the shell has been read.
/// Names the overlay sets are left out: [`host_env`] gives them their value.
pub fn shell_env() -> impl Iterator<Item = (OsString, OsString)> {
shell_env_for(None)
}
/// [`shell_env`] for a child started in `dir`: names the environment of the project holding
/// it sets are left out too.
pub fn shell_env_in(dir: &Path) -> impl Iterator<Item = (OsString, OsString)> {
shell_env_for(Some(dir))
}
fn shell_env_for(dir: Option<&Path>) -> impl Iterator<Item = (OsString, OsString)> {
let overlay = env_overlay();
let project = dir.map(crate::project_env::for_dir).unwrap_or_default();
let vars = login_env().unwrap_or_default();
let lacking: Vec<_> = vars
.iter()
.filter(|(k, _)| std::env::var_os(k).is_none() && !overlay.iter().any(|(o, _)| o == k))
.filter(|(k, _)| {
std::env::var_os(k).is_none()
&& !overlay.iter().any(|(o, _)| o == k)
&& !project.iter().any(|(p, _)| p == k)
})
.cloned()
.collect();
lacking.into_iter()
@@ -1015,6 +1059,45 @@ mod tests {
set_env_overlay(Vec::new());
}
#[test]
fn a_child_inside_a_project_gets_its_environment() {
let root = std::path::Path::new("/openidea-test-process/project");
crate::project_env::set(
root,
vec![
("OPENIDEA_PROJECT_VAR".into(), Some("devshell".into())),
("PATH".into(), Some("/nix/store/x-devshell/bin".into())),
("OPENIDEA_PROJECT_UNSET".into(), None),
],
);
let get = |cmd: &Command, k: &str| cmd.get_envs().find(|(n, _)| *n == k).map(|(_, v)| v.map(OsStr::to_owned));
let mut inside = Command::new("true");
inside.current_dir(root.join("src")).env("OPENIDEA_PROJECT_VAR", "call site");
host_env(&mut inside);
assert_eq!(get(&inside, "PATH"), Some(Some("/nix/store/x-devshell/bin".into())));
assert_eq!(get(&inside, "OPENIDEA_PROJECT_UNSET"), Some(None));
assert_eq!(get(&inside, "OPENIDEA_PROJECT_VAR"), Some(Some("call site".into())), "the call site's value wins");
let mut outside = Command::new("true");
outside.current_dir("/openidea-test-process/other");
host_env(&mut outside);
assert_eq!(get(&outside, "OPENIDEA_PROJECT_VAR"), None);
let mut no_dir = Command::new("true");
host_env(&mut no_dir);
assert_eq!(get(&no_dir, "OPENIDEA_PROJECT_VAR"), None);
// Spawners that build the environment themselves (PTYs, runs) and `PATH` lookups.
assert!(host_env_fixes_in(root).iter().any(|(k, v)| k == "OPENIDEA_PROJECT_VAR" && v.is_some()));
assert!(host_vars_in(root).any(|(k, v)| k == "OPENIDEA_PROJECT_VAR" && v == "devshell"));
assert_eq!(host_var_os_in(root, "OPENIDEA_PROJECT_VAR"), Some("devshell".into()));
assert_eq!(host_var_os("OPENIDEA_PROJECT_VAR"), None);
let search = crate::tool_path::search_path_in(root);
assert_eq!(std::env::split_paths(&search).next(), Some("/nix/store/x-devshell/bin".into()));
crate::project_env::remove(root);
assert!(host_vars_in(root).all(|(k, _)| k != "OPENIDEA_PROJECT_VAR"));
}
#[test]
fn changes_apply_in_order() {
let vars = apply_changes(
+138
Переглянути файл
@@ -0,0 +1,138 @@
//! Environments of project folders (a project's direnv `.envrc`), for the children started
//! inside them. One process can hold several projects (desktop windows), so unlike the
//! process-wide overlay ([`crate::process::set_env_overlay`]) these are kept per root and
//! found from a child's working directory: see [`crate::process::host_env`] and the `_in`
//! variants next to it.
use crate::CancellationToken;
use std::ffi::OsString;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Condvar, Mutex, MutexGuard};
use std::time::Duration;
pub type Changes = Arc<Vec<(OsString, Option<OsString>)>>;
struct Entry {
root: PathBuf,
changes: Changes,
loading: bool,
}
static ENTRIES: Mutex<Vec<Entry>> = Mutex::new(Vec::new());
static SETTLED: Condvar = Condvar::new();
fn entries() -> MutexGuard<'static, Vec<Entry>> {
ENTRIES.lock().unwrap_or_else(|e| e.into_inner())
}
/// `root`'s environment is being read: [`wait`] blocks until [`set`] or [`remove`]. Children
/// started meanwhile keep getting the last one read.
pub fn begin_loading(root: &Path) {
let mut entries = entries();
match entries.iter_mut().find(|e| e.root == root) {
Some(entry) => entry.loading = true,
None => entries.push(Entry { root: root.to_path_buf(), changes: Changes::default(), loading: true }),
}
}
/// What children started in `root` (or below it) get on top of the IDE's own environment
/// (`None`: removed). Ends a [`begin_loading`].
pub fn set(root: &Path, changes: Vec<(OsString, Option<OsString>)>) {
let mut entries = entries();
let changes = Arc::new(changes);
match entries.iter_mut().find(|e| e.root == root) {
Some(entry) => {
entry.changes = changes;
entry.loading = false;
}
None => entries.push(Entry { root: root.to_path_buf(), changes, loading: false }),
}
SETTLED.notify_all();
}
/// Ends a [`begin_loading`] that read nothing new (an error): the last environment stays.
pub fn settle(root: &Path) {
if let Some(entry) = entries().iter_mut().find(|e| e.root == root) {
entry.loading = false;
}
SETTLED.notify_all();
}
/// `root` has no environment of its own any more (closed, or not trusted).
pub fn remove(root: &Path) {
entries().retain(|e| e.root != root);
SETTLED.notify_all();
}
/// The innermost root holding `dir`.
fn find<'a>(entries: &'a [Entry], dir: &Path) -> Option<&'a Entry> {
entries.iter().filter(|e| dir.starts_with(&e.root)).max_by_key(|e| e.root.components().count())
}
/// The environment of the project holding `dir` (empty outside every project, or before it was read).
pub fn for_dir(dir: &Path) -> Changes {
find(&entries(), dir).map(|e| e.changes.clone()).unwrap_or_default()
}
/// Whether the environment of the project holding `dir` is being read.
pub fn is_loading(dir: &Path) -> bool {
find(&entries(), dir).is_some_and(|e| e.loading)
}
/// Blocks while the environment of the project holding `dir` is being read, or until `cancel`.
/// For what must not start without it: language servers.
pub fn wait(dir: &Path, cancel: &CancellationToken) {
let mut entries = entries();
while !cancel.is_cancelled() && find(&entries, dir).is_some_and(|e| e.loading) {
entries = SETTLED.wait_timeout(entries, Duration::from_millis(200)).unwrap_or_else(|e| e.into_inner()).0;
}
}
#[cfg(test)]
mod tests {
use super::*;
fn change(k: &str, v: Option<&str>) -> (OsString, Option<OsString>) {
(k.into(), v.map(Into::into))
}
#[test]
fn the_innermost_project_holding_a_folder_applies() {
let outer = Path::new("/openidea-test-env/outer");
let inner = Path::new("/openidea-test-env/outer/inner");
set(outer, vec![change("A", Some("outer"))]);
set(inner, vec![change("A", Some("inner")), change("B", None)]);
assert_eq!(*for_dir(&outer.join("src")), [change("A", Some("outer"))]);
assert_eq!(*for_dir(&inner.join("src/deep")), [change("A", Some("inner")), change("B", None)]);
assert!(for_dir(Path::new("/openidea-test-env/outer-sibling")).is_empty(), "whole components only");
remove(inner);
assert_eq!(*for_dir(inner), [change("A", Some("outer"))]);
remove(outer);
assert!(for_dir(inner).is_empty());
}
#[test]
fn waiting_ends_once_the_environment_is_read() {
let root = Path::new("/openidea-test-env/waiting");
set(root, vec![change("OLD", Some("1"))]);
begin_loading(root);
assert!(is_loading(&root.join("src")));
assert_eq!(*for_dir(root), [change("OLD", Some("1"))], "the last one read stays until then");
let reader = std::thread::spawn(|| {
std::thread::sleep(Duration::from_millis(100));
set(Path::new("/openidea-test-env/waiting"), vec![change("NEW", Some("2"))]);
});
wait(&root.join("src"), &CancellationToken::new());
assert_eq!(*for_dir(root), [change("NEW", Some("2"))]);
reader.join().unwrap();
begin_loading(root);
let cancel = CancellationToken::new();
cancel.cancel();
wait(root, &cancel);
settle(root);
assert!(!is_loading(root));
assert_eq!(*for_dir(root), [change("NEW", Some("2"))]);
remove(root);
}
}
+30
Переглянути файл
@@ -783,6 +783,35 @@ pub struct AppearanceSettings {
pub main_toolbar: Option<MainToolbarSettings>,
/// Appearance › Background Image: an image shown through the IDE window.
pub background_image: BackgroundImageSettings,
/// Appearance › Presentation Assistant: the name and shortcut of each action run.
pub presentation_assistant: PresentationAssistantSettings,
}
/// Appearance › Presentation Assistant: shows the name and shortcut of each action the user runs.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct PresentationAssistantSettings {
pub enabled: bool,
/// `small` | `medium` | `large`.
pub size: String,
/// How long each popup stays, in seconds.
pub duration_seconds: u32,
/// `top-left`, `top`, `top-right`, `bottom-left`, `bottom` or `bottom-right` of the window.
pub position: String,
/// Also show the shortcut of the other platform's keymap (macOS ⇄ Windows/Linux).
pub alternate_keymap: bool,
}
impl Default for PresentationAssistantSettings {
fn default() -> Self {
Self {
enabled: false,
size: "medium".into(),
duration_seconds: 4,
position: "bottom".into(),
alternate_keymap: false,
}
}
}
/// Appearance › Background Image. An empty `path` shows no image.
@@ -875,6 +904,7 @@ impl Default for AppearanceSettings {
status_bar_widgets: BTreeMap::new(),
main_toolbar: None,
background_image: BackgroundImageSettings::default(),
presentation_assistant: PresentationAssistantSettings::default(),
}
}
}
+16 -2
Переглянути файл
@@ -2,7 +2,7 @@
//! their settings come from, installers. An app started from the desktop gets a
//! minimal `PATH`, and version managers set theirs up in shell rc files.
use crate::process::{host_var_os, login_env};
use crate::process::{host_var_os, host_var_os_in, login_env};
use crate::version_managers;
use std::collections::HashSet;
use std::ffi::{OsStr, OsString};
@@ -14,6 +14,16 @@ use std::path::{Path, PathBuf};
/// launchers, their settings hooks and tool detection all look here, so a settings
/// hook finds the executable its server is launched from.
pub fn search_path() -> OsString {
search_path_for(None)
}
/// [`search_path`] for a child started in `dir`: the `PATH` of the project holding it
/// ([`crate::project_env`], e.g. a Nix devshell's) comes first.
pub fn search_path_in(dir: &Path) -> OsString {
search_path_for(Some(dir))
}
fn search_path_for(dir: Option<&Path>) -> OsString {
let home = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).map(PathBuf::from);
let shell_path = login_env().and_then(|env| env.iter().find(|(k, _)| k == "PATH").map(|(_, v)| v.clone()));
let shims: Vec<PathBuf> = version_managers::managers().iter().map(|m| m.shims()).collect();
@@ -21,7 +31,11 @@ pub fn search_path() -> OsString {
// entries after the inherited ones so missing user tools still resolve.
let user_path = crate::process::user_path();
let dirs = search_dirs(
host_var_os("PATH").as_deref(),
match dir {
Some(dir) => host_var_os_in(dir, "PATH"),
None => host_var_os("PATH"),
}
.as_deref(),
shell_path.as_deref(),
user_path.as_deref(),
home.as_deref(),
+3
Переглянути файл
@@ -135,6 +135,8 @@ pub struct CommitSettings {
/// `Settings::default()`, or `SettingsStore::set` rejects the key as unknown.
#[specta(optional)]
pub double_click_opens_diff: Option<bool>,
/// Team conventions for Generate Commit Message with Agent, added to its prompt.
pub agent_instructions: String,
}
impl Default for CommitSettings {
@@ -156,6 +158,7 @@ impl Default for CommitSettings {
wrap_at_margin: false,
disabled_plugin_checks: Vec::new(),
double_click_opens_diff: None,
agent_instructions: String::new(),
}
}
}
+1 -2
Переглянути файл
@@ -214,9 +214,8 @@ pub fn collect(spec: &CoverageReportSpec) -> IdeResult<CoverageSuite> {
CoverageReportSpec::Exported { runner, argv, cwd, env, lcov } => {
let (program, args) =
argv.split_first().ok_or_else(|| IdeError::invalid("empty coverage export command"))?;
let out = ide_core::process::prepare(&mut Command::new(program))
let out = ide_core::process::prepare(Command::new(program).current_dir(cwd))
.args(args)
.current_dir(cwd)
.envs(env)
.output()
.map_err(|e| IdeError::unavailable(format!("cannot run {program}: {e}")))?;
+17 -14
Переглянути файл
@@ -281,15 +281,16 @@ fn managed_dirs(root: &Path) -> Vec<PathBuf> {
/// The `PATH` an adapter runs with, unless its launch sets one: the search path language servers
/// get, so what it starts in turn (js-debug's wrapper runs `node`, Delve runs `go build`) is
/// found like Run finds it, even when the login shell's `PATH` didn't reach the app.
fn adapter_path(env: &[(String, String)]) -> Option<std::ffi::OsString> {
fn adapter_path(env: &[(String, String)], cwd: &Path) -> Option<std::ffi::OsString> {
let own = env.iter().any(|(k, _)| if cfg!(windows) { k.eq_ignore_ascii_case("PATH") } else { k == "PATH" });
(!own).then(ide_core::tool_path::search_path)
(!own).then(|| ide_core::tool_path::search_path_in(cwd))
}
/// Directories searched for adapter binaries: managed tools first, then `PATH` and the usual install spots.
fn search_dirs() -> Vec<PathBuf> {
/// Directories searched for adapter binaries: managed tools first, then `PATH` (the project's
/// holding `cwd` first) and the usual install spots.
fn search_dirs(cwd: &Path) -> Vec<PathBuf> {
let mut dirs: Vec<PathBuf> = tools_root().map(|r| managed_dirs(&r)).unwrap_or_default();
dirs.extend(std::env::split_paths(&ide_core::tool_path::search_path()));
dirs.extend(std::env::split_paths(&ide_core::tool_path::search_path_in(cwd)));
if let Some(home) = std::env::var_os("HOME").map(PathBuf::from) {
for rel in [".cargo/bin", ".local/bin", "go/bin", ".dotnet/tools", ".bun/bin", ".npm-global/bin", ".volta/bin"]
{
@@ -318,7 +319,7 @@ fn is_executable(path: &Path, windows: bool) -> bool {
/// extensionless script next to a shim is never started as a program.
pub fn find_binary(command: &str, cwd: &Path) -> Option<PathBuf> {
let pathext = std::env::var("PATHEXT").ok();
find_binary_in(command, cwd, &search_dirs(), cfg!(windows), pathext.as_deref())
find_binary_in(command, cwd, &search_dirs(cwd), cfg!(windows), pathext.as_deref())
}
fn find_binary_in(
@@ -377,10 +378,10 @@ pub async fn prepare_debugpy(spec: &mut AdapterSpec) -> IdeResult<()> {
return Ok(()); // Reported as a missing adapter when it is started.
};
let mut probe = Command::new(&python);
probe.current_dir(&spec.cwd);
ide_core::process::prepare(probe.as_std_mut());
let probe = probe
.args(["-c", "import debugpy.adapter"])
.current_dir(&spec.cwd)
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
@@ -452,13 +453,13 @@ pub fn parse_gdb_version(output: &str) -> Option<(u32, u32)> {
/// Probe the already resolved and verified executable with its launch environment.
async fn gdb_version(binary: &Path, spec: &AdapterSpec) -> IdeResult<Option<(u32, u32)>> {
let mut probe = Command::new(binary);
if let Some(path) = adapter_path(&spec.env) {
if let Some(path) = adapter_path(&spec.env, &spec.cwd) {
probe.env("PATH", path);
}
probe.current_dir(&spec.cwd);
ide_core::process::prepare(probe.as_std_mut());
let probe = probe
.arg("--version")
.current_dir(&spec.cwd)
.envs(spec.env.iter().cloned())
.stdin(Stdio::null())
.stdout(Stdio::piped())
@@ -690,9 +691,11 @@ async fn spawn_adapter(
) -> IdeResult<AdapterIo> {
let stderr = Arc::new(parking_lot::Mutex::new(Vec::new()));
let mut cmd = Command::new(binary);
if let Some(path) = adapter_path(&spec.env) {
if let Some(path) = adapter_path(&spec.env, &spec.cwd) {
cmd.env("PATH", path);
}
// The working directory first: it picks the project's environment.
cmd.current_dir(&spec.cwd);
ide_core::process::prepare(cmd.as_std_mut());
// Every adapter leads its own process group: the program an adapter launches itself
// (java-debug's JVM) joins the group, so a forced stop reaches the whole tree with
@@ -700,7 +703,6 @@ async fn spawn_adapter(
ide_core::process::own_group(cmd.as_std_mut());
cmd.args(args)
.envs(spec.env.iter().map(|(k, v)| (k, v)))
.current_dir(&spec.cwd)
.stdin(if port.is_some() { Stdio::null() } else { Stdio::piped() })
.stdout(Stdio::piped())
.stderr(Stdio::piped())
@@ -843,10 +845,11 @@ mod tests {
#[test]
fn adapters_run_on_the_tool_search_path() {
let search = ide_core::tool_path::search_path();
assert_eq!(adapter_path(&[]), Some(search.clone()));
assert_eq!(adapter_path(&[("GOFLAGS".into(), "-mod=mod".into())]), Some(search));
let cwd = Path::new("/openidea-test-no-project");
assert_eq!(adapter_path(&[], cwd), Some(search.clone()));
assert_eq!(adapter_path(&[("GOFLAGS".into(), "-mod=mod".into())], cwd), Some(search));
// A launch that sets its own (a selected Go SDK's bin first) keeps it.
assert_eq!(adapter_path(&[("PATH".into(), "/sdk/go/bin:/usr/bin".into())]), None);
assert_eq!(adapter_path(&[("PATH".into(), "/sdk/go/bin:/usr/bin".into())], cwd), None);
// The search path reaches the usual install spots even when this process's `PATH` doesn't.
#[cfg(unix)]
{
+1 -1
Переглянути файл
@@ -55,10 +55,10 @@ pub async fn build(
) -> IdeResult<PathBuf> {
let cargo = find_binary("cargo", cwd).ok_or_else(|| IdeError::unavailable("`cargo` not found on PATH"))?;
let mut cmd = tokio::process::Command::new(cargo);
cmd.current_dir(cwd);
ide_core::process::prepare(cmd.as_std_mut());
cmd.args(args)
.arg("--message-format=json-render-diagnostics")
.current_dir(cwd)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
+15 -1
Переглянути файл
@@ -216,7 +216,21 @@ pub(crate) async fn serve(
}
}
if holding {
let _ = write.send(call("Fetch.disable", json!({})).1).await;
let (disable, command) = call("Fetch.disable", json!({}));
if write.send(command).await.is_ok() {
// Wait until the proxy has disabled interception before closing the
// socket. Dropping it with unread replies can reset the connection.
let _ = tokio::time::timeout(REQUEST_TIMEOUT, async {
while let Some(Ok(message)) = read.next().await {
let Ok(text) = message.to_text() else { continue };
let Ok(reply) = serde_json::from_str::<Value>(text) else { continue };
if reply.get("id").and_then(Value::as_u64) == Some(disable) {
break;
}
}
})
.await;
}
}
let _ = write.close().await;
}
+6 -8
Переглянути файл
@@ -979,20 +979,18 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
let mut cmd = CommandBuilder::new(program);
// CodeLLDB's launcher clears the terminal first; the console keeps the session's earlier output.
cmd.args(rest.iter().filter(|a| *a != "--clear-screen"));
for (k, v) in ide_core::process::host_env_fixes() {
let cwd = args.get("cwd").and_then(Value::as_str).filter(|c| !c.is_empty()).map_or(s.spec.cwd.as_path(), Path::new);
for (k, v) in ide_core::process::host_env_fixes_in(cwd) {
match v {
Some(v) => cmd.env(k, v),
None => cmd.env_remove(k),
}
}
for (k, v) in ide_core::process::shell_env() {
for (k, v) in ide_core::process::shell_env_in(cwd) {
cmd.env(k, v);
}
cmd.env("TERM", "xterm-256color");
match args.get("cwd").and_then(Value::as_str).filter(|c| !c.is_empty()) {
Some(cwd) => cmd.cwd(cwd),
None => cmd.cwd(&s.spec.cwd),
}
cmd.cwd(cwd);
if let Some(env) = args.get("env").and_then(Value::as_object) {
for (k, v) in env {
match v.as_str() {
@@ -1163,6 +1161,7 @@ pub(crate) async fn start_kotlin_debuggee(s: &Arc<Session>, args: &mut Value) ->
let classpath =
std::env::join_paths(strings("classPaths")).map_err(|e| ide_core::IdeError::invalid(e.to_string()))?;
let mut cmd = tokio::process::Command::new(java);
cmd.current_dir(&s.spec.cwd);
ide_core::process::prepare(cmd.as_std_mut());
cmd.args(kotlin_jvm_args(strings("vmArguments"), cfg!(windows)))
// Let the JVM pick its own port (`:0`) and report it below: pre-picking a free
@@ -1181,8 +1180,7 @@ pub(crate) async fn start_kotlin_debuggee(s: &Arc<Session>, args: &mut Value) ->
.ok_or_else(|| ide_core::IdeError::invalid("Missing Kotlin main class"))?,
)
.args(strings("programArgs"))
.current_dir(&s.spec.cwd)
.envs(ide_core::process::shell_env())
.envs(ide_core::process::shell_env_in(&s.spec.cwd))
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
+4 -4
Переглянути файл
@@ -812,16 +812,16 @@ impl DbManager {
let password = self.password(&source).await;
// Holding the tunnel keeps it open while the tool runs, even if the tree disconnects.
let (target, _tunnel) = self.endpoint(&source, None, true).await?;
let prepared = tools::prepare(job, &target, password.as_deref());
tools::run(executable, &prepared.args, &prepared.env, cancel, on_output).await
let prepared = tools::prepare(job, executable, &target, password.as_deref())?;
tools::run(executable, &prepared.args, &prepared.env, prepared.input.as_deref(), cancel, on_output).await
}
/// The command [`DbManager::run_tool`] would run, for the dialogs' preview: the data source's
/// own host and port (not a tunnel's local end), and no password.
pub fn tool_preview(&self, id: &str, executable: &std::path::Path, job: &tools::DbToolJob) -> IdeResult<String> {
let source = self.source(id)?;
let prepared = tools::prepare(job, &source, None);
Ok(tools::command_line(executable, &prepared.args))
let prepared = tools::prepare(job, executable, &source, None)?;
Ok(tools::command_line(executable, &prepared.args, job.input()))
}
/// The PostgreSQL server's `server_version_num` (`150013` for 15.13).
+215 -4
Переглянути файл
@@ -2,6 +2,7 @@
//! The connection arguments come from [`super::connection`]; these are the rest.
use super::DbTool;
use ide_core::{IdeError, IdeResult};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
@@ -58,6 +59,8 @@ pub struct DbPgDumpOptions {
pub struct DbPgRestoreOptions {
pub content: DbDumpContent,
pub schemas: Vec<String>,
/// Creates the database the archive names; the target is only connected to.
pub create: bool,
pub clean: bool,
pub if_exists: bool,
pub no_owner: bool,
@@ -75,6 +78,40 @@ pub struct DbPsqlOptions {
pub stop_on_error: bool,
}
/// Switches that `mysqldump` turns on by default (`--opt`) only take a flag when turned off.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbMysqldumpOptions {
/// Empty: every database.
pub databases: Vec<String>,
/// Only with exactly one database.
pub tables: Vec<String>,
pub add_drop_table: bool,
pub disable_keys: bool,
pub add_locks: bool,
pub add_drop_trigger: bool,
pub no_data: bool,
pub complete_insert: bool,
pub create_options: bool,
pub routines: bool,
pub events: bool,
/// A consistent InnoDB snapshot without locks; needs no RELOAD privilege.
pub single_transaction: bool,
/// Wins over `single_transaction`.
pub lock_all_tables: bool,
/// `None`: the client has no `--masking-policies`.
pub masking_policies: Option<bool>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbMysqlOptions {
/// Empty: the databases the dump names.
pub database: String,
/// Runs the remaining statements after an error.
pub force: bool,
}
/// A run of a client tool: which one, the file it writes or reads, and its options.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "tool", rename_all = "camelCase")]
@@ -92,6 +129,15 @@ pub enum DbToolJob {
file: String,
options: DbPsqlOptions,
},
Mysqldump {
file: String,
options: DbMysqldumpOptions,
},
/// `file` goes to the standard input.
Mysql {
file: String,
options: DbMysqlOptions,
},
}
impl DbToolJob {
@@ -100,15 +146,38 @@ impl DbToolJob {
DbToolJob::PgDump { .. } => DbTool::PgDump,
DbToolJob::PgRestore { .. } => DbTool::PgRestore,
DbToolJob::Psql { .. } => DbTool::Psql,
DbToolJob::Mysqldump { .. } => DbTool::Mysqldump,
DbToolJob::Mysql { .. } => DbTool::Mysql,
}
}
/// The file piped to the tool's standard input.
pub fn input(&self) -> Option<&str> {
match self {
DbToolJob::Mysql { file, .. } if !file.is_empty() => Some(file),
_ => None,
}
}
/// Refuses names that the tool would read as options: `mysqldump` takes databases and tables
/// as plain arguments.
pub fn check(&self) -> IdeResult<()> {
if let DbToolJob::Mysqldump { options, .. } = self
&& let Some(name) = options.databases.iter().chain(&options.tables).find(|n| n.trim().starts_with('-'))
{
return Err(IdeError::invalid(format!("mysqldump cannot dump a database or table named {name}")));
}
Ok(())
}
/// The arguments after the connection ones.
pub fn args(&self) -> Vec<String> {
match self {
DbToolJob::PgDump { file, options } => pg_dump(options, file),
DbToolJob::PgRestore { file, options } => pg_restore(options, file),
DbToolJob::Psql { file, options } => psql(options, file),
DbToolJob::Mysqldump { file, options } => mysqldump(options, file),
DbToolJob::Mysql { options, .. } => mysql(options),
}
}
}
@@ -162,6 +231,7 @@ fn pg_dump(o: &DbPgDumpOptions, file: &str) -> Vec<String> {
fn pg_restore(o: &DbPgRestoreOptions, file: &str) -> Vec<String> {
let mut args: Vec<String> = content(o.content).into_iter().collect();
args.extend(each(&o.schemas, "schema"));
args.extend(flag(o.create, "--create"));
args.extend(flag(o.clean, "--clean"));
args.extend(flag(o.clean && o.if_exists, "--if-exists"));
args.extend(flag(o.no_owner, "--no-owner"));
@@ -187,8 +257,53 @@ fn psql(o: &DbPsqlOptions, file: &str) -> Vec<String> {
args
}
/// The command as a shell would need it typed: the dialogs' preview.
pub fn command_line(program: &Path, args: &[String]) -> String {
fn names(list: &[String]) -> impl Iterator<Item = String> {
list.iter().map(|n| n.trim()).filter(|n| !n.is_empty()).map(str::to_owned)
}
fn mysqldump(o: &DbMysqldumpOptions, file: &str) -> Vec<String> {
let skip = |on: bool, option: &str| (!on).then(|| format!("--skip-{option}"));
let mut args = vec![format!("--result-file={file}")];
args.extend(skip(o.add_drop_table, "add-drop-table"));
args.extend(skip(o.disable_keys, "disable-keys"));
args.extend(skip(o.add_locks, "add-locks"));
args.extend(skip(o.create_options, "create-options"));
args.extend(flag(o.add_drop_trigger, "--add-drop-trigger"));
args.extend(flag(o.no_data, "--no-data"));
args.extend(flag(o.complete_insert, "--complete-insert"));
args.extend(flag(o.routines, "--routines"));
args.extend(flag(o.events, "--events"));
args.extend(flag(o.lock_all_tables, "--lock-all-tables"));
args.extend(flag(!o.lock_all_tables && o.single_transaction, "--single-transaction"));
// On by default where it exists; reading the policies needs privileges most users lack.
args.extend(flag(o.masking_policies == Some(false), "--skip-masking-policies"));
// Tablespace statements need the PROCESS privilege and rarely matter in a dump.
args.push("--no-tablespaces".into());
args.push("--verbose".into());
let databases: Vec<String> = names(&o.databases).collect();
match databases.as_slice() {
[] => args.push("--all-databases".into()),
[one] => {
args.push(one.clone());
args.extend(names(&o.tables));
}
_ => {
args.push("--databases".into());
args.extend(databases);
}
}
args
}
fn mysql(o: &DbMysqlOptions) -> Vec<String> {
let database = o.database.trim();
let mut args: Vec<String> = (!database.is_empty()).then(|| format!("--database={database}")).into_iter().collect();
args.extend(flag(o.force, "--force"));
args
}
/// The command as a shell would need it typed: the dialogs' preview. `input` is piped in.
pub fn command_line(program: &Path, args: &[String], input: Option<&str>) -> String {
let quote = |s: &str| {
if !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || "@%+=:,./-_".contains(c)) {
s.to_owned()
@@ -196,11 +311,15 @@ pub fn command_line(program: &Path, args: &[String]) -> String {
format!("'{}'", s.replace('\'', "'\\''"))
}
};
std::iter::once(program.to_string_lossy().into_owned())
let line = std::iter::once(program.to_string_lossy().into_owned())
.chain(args.iter().cloned())
.map(|a| quote(&a))
.collect::<Vec<_>>()
.join(" ")
.join(" ");
match input {
Some(file) => format!("{line} < {}", quote(file)),
None => line,
}
}
#[cfg(test)]
@@ -228,6 +347,7 @@ mod tests {
DbPgRestoreOptions {
content: DbDumpContent::All,
schemas: vec![],
create: false,
clean: false,
if_exists: false,
no_owner: false,
@@ -308,6 +428,13 @@ mod tests {
);
}
#[test]
fn creates_the_database_of_the_archive_when_asked() {
let options = DbPgRestoreOptions { create: true, ..restore() };
let a = args(DbToolJob::PgRestore { file: "/tmp/shop.dump".into(), options });
assert_eq!(a, ["--create", "--exit-on-error", "--verbose", "/tmp/shop.dump"]);
}
#[test]
fn leaves_out_an_archive_not_chosen_yet() {
let a = args(DbToolJob::PgRestore { file: String::new(), options: restore() });
@@ -328,8 +455,92 @@ mod tests {
let line = command_line(
Path::new("/usr/bin/pg_dump"),
&["--port=5432".into(), "--file=/tmp/my dump.sql".into(), "--table=it's".into()],
None,
);
assert_eq!(line, r#"/usr/bin/pg_dump --port=5432 '--file=/tmp/my dump.sql' '--table=it'\''s'"#);
let line = command_line(Path::new("mysql"), &["--force".into()], Some("/tmp/my dump.sql"));
assert_eq!(line, "mysql --force < '/tmp/my dump.sql'");
}
fn mysqldump_options() -> DbMysqldumpOptions {
DbMysqldumpOptions {
databases: vec!["shop".into()],
tables: vec![],
add_drop_table: true,
disable_keys: true,
add_locks: true,
add_drop_trigger: false,
no_data: false,
complete_insert: false,
create_options: true,
routines: false,
events: false,
single_transaction: true,
lock_all_tables: false,
masking_policies: None,
}
}
#[test]
fn mysqldump_flags_only_what_differs_from_its_defaults() {
let job = DbToolJob::Mysqldump { file: "/tmp/shop.sql".into(), options: mysqldump_options() };
assert_eq!(
args(job),
["--result-file=/tmp/shop.sql", "--single-transaction", "--no-tablespaces", "--verbose", "shop"]
);
let options = DbMysqldumpOptions {
add_drop_table: false,
create_options: false,
routines: true,
lock_all_tables: true,
masking_policies: Some(false),
..mysqldump_options()
};
let a = args(DbToolJob::Mysqldump { file: "/tmp/x.sql".into(), options });
for expected in ["--skip-add-drop-table", "--skip-create-options", "--routines", "--lock-all-tables"] {
assert!(a.contains(&expected.to_owned()), "{expected} missing from {a:?}");
}
assert!(a.contains(&"--skip-masking-policies".to_owned()), "{a:?}");
assert!(!a.contains(&"--single-transaction".to_owned()), "{a:?}");
}
#[test]
fn mysqldump_names_tables_only_of_a_single_database() {
let tables = vec!["orders".to_owned(), "items".to_owned()];
let one = DbMysqldumpOptions { tables: tables.clone(), ..mysqldump_options() };
assert!(args(DbToolJob::Mysqldump { file: "f".into(), options: one }).ends_with(&[
"shop".into(),
"orders".into(),
"items".into()
]));
let two = DbMysqldumpOptions { databases: vec!["a".into(), "b".into()], tables, ..mysqldump_options() };
assert!(args(DbToolJob::Mysqldump { file: "f".into(), options: two }).ends_with(&[
"--databases".into(),
"a".into(),
"b".into()
]));
let all = DbMysqldumpOptions { databases: vec![], ..mysqldump_options() };
assert_eq!(args(DbToolJob::Mysqldump { file: "f".into(), options: all }).last().unwrap(), "--all-databases");
}
#[test]
fn mysqldump_refuses_names_it_would_read_as_options() {
let options = DbMysqldumpOptions { tables: vec!["--result-file=/etc/x".into()], ..mysqldump_options() };
assert!(DbToolJob::Mysqldump { file: "f".into(), options }.check().is_err());
assert!(DbToolJob::Mysqldump { file: "f".into(), options: mysqldump_options() }.check().is_ok());
}
#[test]
fn mysql_reads_the_dump_from_its_standard_input() {
let job = DbToolJob::Mysql {
file: "/tmp/shop.sql".into(),
options: DbMysqlOptions { database: " shop ".into(), force: true },
};
assert_eq!(args(job.clone()), ["--database=shop", "--force"]);
assert_eq!(job.input(), Some("/tmp/shop.sql"));
let none =
DbToolJob::Mysql { file: String::new(), options: DbMysqlOptions { database: String::new(), force: false } };
assert!(args(none.clone()).is_empty() && none.input().is_none());
}
#[test]
+336 -48
Переглянути файл
@@ -1,5 +1,6 @@
//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`): finding installed copies, the
//! arguments and environment that connect them like the data source, and running them.
//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`, `mysqldump`, `mysql`): finding
//! installed copies, the arguments and environment that connect them like the data source, and
//! running them.
mod jobs;
pub use jobs::*;
@@ -20,6 +21,8 @@ pub enum DbTool {
PgDump,
PgRestore,
Psql,
Mysqldump,
Mysql,
}
impl DbTool {
@@ -27,20 +30,25 @@ impl DbTool {
self.programs()[0]
}
/// Executable names.
/// Executable names, MariaDB's own after MySQL's.
pub fn programs(self) -> &'static [&'static str] {
match self {
DbTool::PgDump => &["pg_dump"],
DbTool::PgRestore => &["pg_restore"],
DbTool::Psql => &["psql"],
DbTool::Mysqldump => &["mysqldump", "mariadb-dump"],
DbTool::Mysql => &["mysql", "mariadb"],
}
}
pub fn driver(self) -> DbDriver {
DbDriver::Postgres
match self {
DbTool::PgDump | DbTool::PgRestore | DbTool::Psql => DbDriver::Postgres,
DbTool::Mysqldump | DbTool::Mysql => DbDriver::Mysql,
}
}
/// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`…).
/// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`, `mariadb-dump`…).
/// The data source's password is handed only to such a program.
pub fn is_program(self, path: &Path) -> bool {
let Some(stem) = path.file_stem().and_then(OsStr::to_str) else { return false };
@@ -53,6 +61,12 @@ impl DbTool {
}
}
/// Whether `executable` is MariaDB's client (`mariadb`, `mariadb-dump`), whose SSL options differ
/// from MySQL's.
fn is_mariadb(executable: &Path) -> bool {
executable.file_stem().and_then(OsStr::to_str).is_some_and(|s| s.starts_with("mariadb"))
}
/// An installed copy of a tool.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", rename = "DbToolInstall")]
@@ -70,28 +84,41 @@ pub struct ToolLine {
pub text: String,
}
/// Directories holding the tools that are often missing from `PATH`, by platform.
fn known_dirs() -> Vec<PathBuf> {
/// Directories holding the tools of `driver` that are often missing from `PATH`, by platform.
fn known_dirs(driver: DbDriver) -> Vec<PathBuf> {
let mysql = driver == DbDriver::Mysql;
let mut dirs = Vec::new();
if cfg!(target_os = "macos") {
for prefix in ["/opt/homebrew", "/usr/local"] {
dirs.push(PathBuf::from(format!("{prefix}/bin")));
let opt = PathBuf::from(format!("{prefix}/opt"));
for keg in ["libpq", "postgresql"] {
let kegs: &[&str] = if mysql { &["mysql-client", "mysql", "mariadb"] } else { &["libpq", "postgresql"] };
for keg in kegs {
dirs.extend(children(&opt, keg).into_iter().map(|d| d.join("bin")));
}
}
dirs.extend(
children(Path::new("/Applications/Postgres.app/Contents/Versions"), "").into_iter().map(|d| d.join("bin")),
);
if mysql {
dirs.push(PathBuf::from("/usr/local/mysql/bin"));
} else {
dirs.extend(
children(Path::new("/Applications/Postgres.app/Contents/Versions"), "")
.into_iter()
.map(|d| d.join("bin")),
);
}
} else if cfg!(windows) {
for var in ["ProgramFiles", "ProgramFiles(x86)"] {
if let Some(base) = std::env::var_os(var) {
let root = PathBuf::from(base).join("PostgreSQL");
dirs.extend(children(&root, "").into_iter().map(|d| d.join("bin")));
let base = PathBuf::from(base);
// MySQL installs to `MySQL\MySQL Server 8.4`, MariaDB to `MariaDB 11.4`.
let roots: &[(&str, &str)] =
if mysql { &[("MySQL", "MySQL"), ("", "MariaDB")] } else { &[("PostgreSQL", "")] };
for (dir, prefix) in roots {
dirs.extend(children(&base.join(dir), prefix).into_iter().map(|d| d.join("bin")));
}
}
}
} else {
} else if !mysql {
dirs.extend(children(Path::new("/usr/lib/postgresql"), "").into_iter().map(|d| d.join("bin")));
dirs.extend(children(Path::new("/usr"), "pgsql-").into_iter().map(|d| d.join("bin")));
}
@@ -121,7 +148,7 @@ fn version_key(text: &str) -> Vec<u32> {
pub fn find_installs(tool: DbTool) -> Vec<ToolInstall> {
let path = ide_core::process::host_var_os("PATH").unwrap_or_default();
let mut dirs: Vec<PathBuf> = std::env::split_paths(&path).collect();
dirs.extend(known_dirs());
dirs.extend(known_dirs(tool.driver()));
let mut seen = Vec::new();
let mut out = Vec::new();
for dir in dirs {
@@ -150,6 +177,29 @@ pub fn version_of(path: &Path) -> IdeResult<String> {
}
}
/// The long options `path --help` lists (`masking-policies` for `--masking-policies`), so a
/// dialog offers only options this copy knows. Blocking.
pub fn options_of(path: &Path) -> IdeResult<Vec<String>> {
let (_, text) = capture(path, "--help")?;
Ok(help_options(&text))
}
fn help_options(help: &str) -> Vec<String> {
let mut out: Vec<String> = help
.lines()
.filter(|l| l.starts_with(' ') && l.trim_start().starts_with('-'))
.filter_map(|l| {
let at = l.find("--")?;
let name: String =
l[at + 2..].chars().take_while(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '_').collect();
(!name.is_empty()).then_some(name)
})
.collect();
out.sort();
out.dedup();
out
}
/// Runs `path arg` for at most five seconds; whether it succeeded, and its standard output.
fn capture(path: &Path, arg: &str) -> IdeResult<(bool, String)> {
if !path.is_file() {
@@ -189,23 +239,41 @@ pub enum DbDumpKind {
PostgresArchive,
/// Plain SQL from `pg_dump`: `psql`.
PostgresSql,
/// `mysqldump` / `mariadb-dump`: not for the PostgreSQL tools.
/// `mysqldump` / `mariadb-dump`: `mysql`.
MysqlSql,
Unknown,
}
/// Blocking: reads at most the first 4 KiB.
pub fn dump_kind(path: &Path) -> IdeResult<DbDumpKind> {
/// What a restore needs to know about a dump before it runs.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", rename = "DbDumpInfo")]
pub struct DumpInfo {
pub kind: DbDumpKind,
/// An SQL dump that runs `CREATE DATABASE` itself: `mysqldump --databases` / `--all-databases`,
/// or `pg_dump --create`. Archives say `false`; `pg_restore --create` decides for them.
pub creates_database: bool,
}
/// Blocking: reads at most the first 64 KiB, where both tools write their `CREATE DATABASE`.
pub fn dump_info(path: &Path) -> IdeResult<DumpInfo> {
use std::io::Read;
if path.is_dir() {
return Ok(if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown });
let kind = if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown };
return Ok(DumpInfo { kind, creates_database: false });
}
let mut head = Vec::with_capacity(4096);
let mut head = Vec::with_capacity(64 * 1024);
std::fs::File::open(path)
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?
.take(4096)
.take(64 * 1024)
.read_to_end(&mut head)?;
Ok(kind_of(&head))
Ok(info_of(&head))
}
fn info_of(head: &[u8]) -> DumpInfo {
let kind = kind_of(head);
let sql = matches!(kind, DbDumpKind::PostgresSql | DbDumpKind::MysqlSql);
let creates_database = sql && String::from_utf8_lossy(head).lines().any(|l| l.starts_with("CREATE DATABASE "));
DumpInfo { kind, creates_database }
}
fn kind_of(head: &[u8]) -> DbDumpKind {
@@ -224,9 +292,12 @@ fn kind_of(head: &[u8]) -> DbDumpKind {
}
}
/// Arguments and environment that connect `tool` to `source` (already resolved, through its
/// tunnel when it has one). The password is left to [`prepare`].
pub fn connection(tool: DbTool, source: &DataSource) -> (Vec<String>, Vec<(String, String)>) {
/// Arguments and environment that connect `tool` at `executable` to `source` (already resolved,
/// through its tunnel when it has one). The password is left to [`prepare`].
pub fn connection(tool: DbTool, executable: &Path, source: &DataSource) -> (Vec<String>, Vec<(String, String)>) {
if tool.driver() == DbDriver::Mysql {
return (mysql_connection(tool, executable, source), Vec::new());
}
let mut args = Vec::new();
let host = source.host.trim();
if !host.is_empty() {
@@ -271,6 +342,50 @@ pub fn connection(tool: DbTool, source: &DataSource) -> (Vec<String>, Vec<(Strin
(args, env)
}
/// The database is the job's: a dump may name several.
fn mysql_connection(tool: DbTool, executable: &Path, source: &DataSource) -> Vec<String> {
let mut args = Vec::new();
let host = source.host.trim();
if !host.is_empty() {
args.push(format!("--host={host}"));
}
args.push(format!("--port={}", source.port.or(source.driver.default_port()).unwrap_or(3306)));
if !source.user.trim().is_empty() {
args.push(format!("--user={}", source.user.trim()));
}
// `localhost` would otherwise mean the Unix socket, not the port or the tunnel.
args.push("--protocol=TCP".into());
if is_mariadb(executable) {
let flags: &[&str] = match source.ssl {
DbSslMode::Disable => &["--skip-ssl"],
DbSslMode::Prefer => &["--skip-ssl-verify-server-cert"],
DbSslMode::Require => &["--ssl", "--skip-ssl-verify-server-cert"],
DbSslMode::VerifyCa | DbSslMode::VerifyFull => &["--ssl", "--ssl-verify-server-cert"],
};
args.extend(flags.iter().map(|f| f.to_string()));
} else {
let mode = match source.ssl {
DbSslMode::Disable => "DISABLED",
DbSslMode::Prefer => "PREFERRED",
DbSslMode::Require => "REQUIRED",
DbSslMode::VerifyCa => "VERIFY_CA",
DbSslMode::VerifyFull => "VERIFY_IDENTITY",
};
args.push(format!("--ssl-mode={mode}"));
}
for (flag, file) in
[("--ssl-ca", &source.ssl_ca_file), ("--ssl-cert", &source.ssl_cert_file), ("--ssl-key", &source.ssl_key_file)]
{
if !file.trim().is_empty() {
args.push(format!("{flag}={}", ide_ssh::expand(file.trim()).to_string_lossy()));
}
}
if tool == DbTool::Mysql && source.read_only {
args.push("--init-command=SET SESSION TRANSACTION READ ONLY".into());
}
args
}
/// `--dbname` reads a connection string or URI as connection parameters: such a database name
/// goes in quoted as the string's `dbname`, so it cannot pick another host or credentials.
fn dbname_arg(name: &str) -> String {
@@ -281,36 +396,88 @@ fn dbname_arg(name: &str) -> String {
}
}
/// How a tool is started: connection arguments, then the job's, and the environment.
/// A MySQL client option file holding the password, readable by the user only; deleted on drop.
struct SecretFile(PathBuf);
impl SecretFile {
fn mysql_password(password: &str) -> IdeResult<Self> {
use std::io::Write;
let path = std::env::temp_dir().join(format!("openidea-mysql-{}.cnf", uuid::Uuid::new_v4()));
let mut options = std::fs::OpenOptions::new();
options.write(true).create_new(true);
#[cfg(unix)]
std::os::unix::fs::OpenOptionsExt::mode(&mut options, 0o600);
let mut file = options.open(&path)?;
let secret = SecretFile(path);
let escaped = password.replace('\\', "\\\\").replace('"', "\\\"");
writeln!(file, "[client]\npassword=\"{escaped}\"")?;
Ok(secret)
}
/// `mysqldump` / `mysql` accept it only as their first argument.
fn arg(&self) -> String {
format!("--defaults-extra-file={}", self.0.display())
}
}
impl Drop for SecretFile {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.0);
}
}
/// How a tool is started: connection arguments, then the job's, the environment, and the file
/// piped to its standard input. Keep it until the tool exits: it owns the password file.
pub struct Prepared {
pub args: Vec<String>,
pub env: Vec<(String, String)>,
pub input: Option<PathBuf>,
_secret: Option<SecretFile>,
}
/// The command for `job` against `source`. The password goes in `PGPASSWORD`, never in the
/// arguments, which other users of the machine can read in the process list.
pub fn prepare(job: &DbToolJob, source: &DataSource, password: Option<&str>) -> Prepared {
let (mut args, mut env) = connection(job.tool(), source);
/// The command for `job` at `executable` against `source`. The password goes in `PGPASSWORD` or
/// a MySQL option file, never in the arguments, which other users of the machine can read in the
/// process list.
pub fn prepare(job: &DbToolJob, executable: &Path, source: &DataSource, password: Option<&str>) -> IdeResult<Prepared> {
job.check()?;
let tool = job.tool();
let (mut args, mut env) = connection(tool, executable, source);
args.extend(job.args());
if let Some(p) = password.filter(|p| !p.is_empty()) {
env.push(("PGPASSWORD".into(), p.to_owned()));
let mut secret = None;
match password.filter(|p| !p.is_empty()) {
Some(p) if tool.driver() == DbDriver::Mysql => {
let file = SecretFile::mysql_password(p)?;
args.insert(0, file.arg());
secret = Some(file);
}
Some(p) => env.push(("PGPASSWORD".into(), p.to_owned())),
None => {}
}
Prepared { args, env }
Ok(Prepared { args, env, input: job.input().map(PathBuf::from), _secret: secret })
}
/// Runs `program` until it exits, passing its output in batches. Returns the exit code
/// (`None`: ended by a signal). Cancelling kills it and everything it started.
/// Runs `program` until it exits, passing its output in batches; `input` is piped to its standard
/// input. Returns the exit code (`None`: ended by a signal). Cancelling kills it and everything it
/// started.
pub async fn run(
program: &Path,
args: &[String],
env: &[(String, String)],
input: Option<&Path>,
cancel: &CancellationToken,
mut on_output: impl FnMut(Vec<ToolLine>),
) -> IdeResult<Option<i32>> {
let stdin = match input {
Some(path) => Stdio::from(
std::fs::File::open(path)
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?,
),
None => Stdio::null(),
};
let mut cmd = tokio::process::Command::new(program);
cmd.args(args)
.envs(env.iter().map(|(k, v)| (k, v)))
.stdin(Stdio::null())
.stdin(stdin)
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
@@ -408,7 +575,7 @@ mod tests {
#[test]
fn connects_like_the_data_source_without_prompting() {
let (args, env) = connection(DbTool::PgDump, &pg());
let (args, env) = connection(DbTool::PgDump, Path::new("pg_dump"), &pg());
assert_eq!(args, ["--host=db.example.test", "--port=6543", "--username=app", "--dbname=shop", "--no-password"]);
assert!(env.contains(&("PGSSLMODE".into(), "prefer".into())));
assert!(!env.iter().any(|(k, _)| k == "PGPASSWORD" || k == "PGOPTIONS"));
@@ -421,7 +588,8 @@ mod tests {
(r"it's=\x", r"--dbname=dbname='it\'s=\\x'"),
("postgresql://evil.example/p", "--dbname=dbname='postgresql://evil.example/p'"),
] {
let (args, _) = connection(DbTool::PgDump, &DataSource { database: name.into(), ..pg() });
let (args, _) =
connection(DbTool::PgDump, Path::new("pg_dump"), &DataSource { database: name.into(), ..pg() });
assert!(args.contains(&arg.to_owned()), "{args:?}");
}
}
@@ -429,14 +597,14 @@ mod tests {
#[test]
fn default_port_and_optional_fields() {
let source = DataSource { port: None, user: String::new(), database: String::new(), ..pg() };
let (args, _) = connection(DbTool::Psql, &source);
let (args, _) = connection(DbTool::Psql, Path::new("psql"), &source);
assert_eq!(args, ["--host=db.example.test", "--port=5432", "--no-password"]);
}
#[test]
fn read_only_sources_refuse_writes() {
let source = DataSource { read_only: true, ssl: DbSslMode::VerifyFull, ..pg() };
let (_, env) = connection(DbTool::PgRestore, &source);
let (_, env) = connection(DbTool::PgRestore, Path::new("pg_restore"), &source);
assert!(env.contains(&("PGOPTIONS".into(), "-c default_transaction_read_only=on".into())));
assert!(env.contains(&("PGSSLMODE".into(), "verify-full".into())));
}
@@ -451,6 +619,77 @@ mod tests {
}
}
#[test]
fn mysql_tools_accept_mariadb_names_only_for_themselves() {
assert!(DbTool::Mysqldump.is_program(Path::new("/usr/bin/mariadb-dump")));
assert!(DbTool::Mysql.is_program(Path::new("/opt/homebrew/opt/mysql-client/bin/mysql")));
assert!(!DbTool::Mysql.is_program(Path::new("/usr/bin/mysqldump")));
assert!(!DbTool::Mysql.is_program(Path::new("/usr/bin/mariadb-dump")));
assert!(!DbTool::Mysqldump.is_program(Path::new("/usr/bin/mysqlpump")));
}
#[test]
fn mysql_connects_over_tcp_with_the_ssl_flags_of_its_client() {
let source = DataSource {
driver: DbDriver::Mysql,
host: "localhost".into(),
port: None,
user: "app".into(),
read_only: true,
..DataSource::default()
};
let (args, env) = connection(DbTool::Mysql, Path::new("/usr/bin/mysql"), &source);
assert_eq!(
args,
[
"--host=localhost",
"--port=3306",
"--user=app",
"--protocol=TCP",
"--ssl-mode=PREFERRED",
"--init-command=SET SESSION TRANSACTION READ ONLY"
]
);
assert!(env.is_empty());
let (args, _) = connection(DbTool::Mysqldump, Path::new("/usr/bin/mariadb-dump"), &source);
assert!(args.contains(&"--skip-ssl-verify-server-cert".to_owned()));
assert!(!args.iter().any(|a| a.starts_with("--ssl-mode") || a.starts_with("--init-command")));
}
#[test]
fn the_password_file_is_private_and_removed() {
let file = SecretFile::mysql_password(r#"p"a\ss"#).unwrap();
let path = file.arg().trim_start_matches("--defaults-extra-file=").to_owned();
let text = std::fs::read_to_string(&path).unwrap();
assert_eq!(text, "[client]\npassword=\"p\\\"a\\\\ss\"\n");
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
assert_eq!(std::fs::metadata(&path).unwrap().permissions().mode() & 0o777, 0o600);
}
drop(file);
assert!(!Path::new(&path).exists());
}
#[test]
fn reads_long_options_from_help() {
let help = "Usage: mysqldump [OPTIONS]\n -A, --all-databases Dump all.\n --masking-policies Dump masking\n policies (--not-an-option).\n -y, --no-tablespaces \n -f, --file=FILENAME output file\n";
assert_eq!(help_options(help), ["all-databases", "file", "masking-policies", "no-tablespaces"]);
}
#[cfg(unix)]
#[tokio::test]
async fn pipes_the_input_file() {
let file = std::env::temp_dir().join(format!("openidea-input-{}", uuid::Uuid::new_v4()));
std::fs::write(&file, "from the file\n").unwrap();
let mut lines = Vec::new();
run(Path::new("/bin/cat"), &[], &[], Some(&file), &CancellationToken::new(), |b| lines.extend(b))
.await
.unwrap();
std::fs::remove_file(&file).unwrap();
assert_eq!(lines, [ToolLine { stderr: false, text: "from the file".into() }]);
}
#[test]
fn tells_dumps_apart_by_their_header() {
assert_eq!(kind_of(b"PGDMP\x01\x0f"), DbDumpKind::PostgresArchive);
@@ -461,6 +700,17 @@ mod tests {
assert_eq!(kind_of(b"CREATE TABLE t (id int);\n"), DbDumpKind::Unknown);
}
#[test]
fn sees_a_dump_that_creates_its_own_database() {
let one = b"-- MySQL dump 10.13\n--\n-- Host: localhost Database: shop\nCREATE TABLE `items` (id int);\n";
assert!(!info_of(one).creates_database);
let several = b"-- MySQL dump 10.13\n--\n-- Current Database: `shop`\n--\n\nCREATE DATABASE /*!32312 IF NOT EXISTS*/ `shop`;\nUSE `shop`;\n";
assert!(info_of(several).creates_database);
let pg = b"--\n-- PostgreSQL database dump\n--\nSET client_encoding = 'UTF8';\nCREATE DATABASE shop WITH TEMPLATE = template0;\n\\connect shop\n";
assert_eq!(info_of(pg), DumpInfo { kind: DbDumpKind::PostgresSql, creates_database: true });
assert!(!info_of(b"CREATE DATABASE x;\n").creates_database, "only for a dump the tools wrote");
}
#[test]
fn newer_versions_sort_first() {
assert!(version_key("pg_dump (PostgreSQL) 17.2") > version_key("pg_dump (PostgreSQL) 9.6.24"));
@@ -474,6 +724,7 @@ mod tests {
Path::new("/bin/sh"),
&["-c".into(), "echo out; echo err >&2; exit 3".into()],
&[],
None,
&CancellationToken::new(),
|batch| lines.extend(batch),
)
@@ -493,19 +744,25 @@ mod tests {
tokio::time::sleep(Duration::from_millis(100)).await;
stop.cancel();
});
let result = run(Path::new("/bin/sh"), &["-c".into(), "sleep 30".into()], &[], &cancel, |_| {}).await;
let result = run(Path::new("/bin/sh"), &["-c".into(), "sleep 30".into()], &[], None, &cancel, |_| {}).await;
assert!(result.is_err());
}
/// A stand-in for `tool` that prints each argument on a line, then whether `PGPASSWORD`
/// holds the expected password.
/// A stand-in for `tool` that prints each argument on a line, then whether it got a password
/// from `PGPASSWORD` or a MySQL option file.
#[cfg(unix)]
fn echo_tool(dir: &Path, tool: DbTool) -> PathBuf {
use std::os::unix::fs::PermissionsExt;
let path = dir.join(tool.program());
std::fs::write(
&path,
"#!/bin/sh\nfor a in \"$@\"; do echo \"arg:$a\"; done\necho \"env:${PGPASSWORD:+set}\"\n",
concat!(
"#!/bin/sh\n",
"for a in \"$@\"; do echo \"arg:$a\"; case \"$a\" in --defaults-extra-file=*)\n",
" grep -q '^password=' \"${a#*=}\" && echo env:set;; esac; done\n",
"[ -n \"$PGPASSWORD\" ] && echo env:set\n",
"exit 0\n",
),
)
.unwrap();
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
@@ -541,17 +798,48 @@ mod tests {
file: file.clone(),
options: DbPsqlOptions { single_transaction: true, stop_on_error: true },
},
DbToolJob::Mysqldump {
file: file.clone(),
options: DbMysqldumpOptions {
databases: vec!["shop".into()],
tables: vec![],
add_drop_table: true,
disable_keys: true,
add_locks: true,
add_drop_trigger: false,
no_data: false,
complete_insert: false,
create_options: true,
routines: false,
events: false,
single_transaction: true,
lock_all_tables: false,
masking_policies: None,
},
},
DbToolJob::Mysql { file: String::new(), options: DbMysqlOptions { database: "shop".into(), force: false } },
];
for job in jobs {
let mysql = job.tool().driver() == DbDriver::Mysql;
let source = if mysql { DataSource { driver: DbDriver::Mysql, ..pg() } } else { pg() };
let program = echo_tool(&dir, job.tool());
let prepared = prepare(&job, &pg(), Some(SECRET));
let prepared = prepare(&job, &program, &source, Some(SECRET)).unwrap();
assert!(!prepared.args.iter().any(|a| a.contains(SECRET)), "{:?}", prepared.args);
assert!(!mysql || prepared.env.is_empty(), "{:?}", prepared.env);
let mut lines = Vec::new();
run(&program, &prepared.args, &prepared.env, &CancellationToken::new(), |b| lines.extend(b)).await.unwrap();
run(&program, &prepared.args, &prepared.env, None, &CancellationToken::new(), |b| lines.extend(b))
.await
.unwrap();
let text: Vec<&str> = lines.iter().map(|l| l.text.as_str()).collect();
assert!(text.contains(&"arg:--dbname=shop"), "{text:?}");
let database = if mysql { "shop" } else { "--dbname=shop" };
assert!(text.iter().any(|l| l.strip_prefix("arg:").is_some_and(|a| a.ends_with(database))), "{text:?}");
assert!(!text.iter().any(|l| l.contains(SECRET)), "{text:?}");
assert!(text.contains(&"env:set"), "the tool gets the password from PGPASSWORD: {text:?}");
assert!(text.contains(&"env:set"), "the tool gets the password: {text:?}");
if mysql {
let file = prepared.args[0].trim_start_matches("--defaults-extra-file=").to_owned();
drop(prepared);
assert!(!Path::new(&file).exists(), "the password file outlives the run");
}
}
std::fs::remove_dir_all(&dir).unwrap();
}
+67
Переглянути файл
@@ -231,3 +231,70 @@ async fn servers_that_advertise_deprecate_eof_but_send_legacy_eof_packets() -> I
assert_eq!(r.rows, vec![vec![Some("a".into())], vec![Some("b".into())]]);
Ok(())
}
/// `mysqldump` into a file and `mysql` reading it back, with the data source's password.
#[tokio::test]
async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> {
use ide_db::tools::{DbMysqlOptions, DbMysqldumpOptions, DbTool, DbToolJob, find_installs};
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp, "").await else { return Ok(()) };
let (Some(dump), Some(client)) =
(find_installs(DbTool::Mysqldump).into_iter().next(), find_installs(DbTool::Mysql).into_iter().next())
else {
return Ok(());
};
let c = CancellationToken::new();
for stmt in [
"DROP DATABASE IF EXISTS oi_dump_src",
"DROP DATABASE IF EXISTS oi_dump_dst",
"CREATE DATABASE oi_dump_src",
"CREATE DATABASE oi_dump_dst",
"CREATE TABLE oi_dump_src.items (id INT PRIMARY KEY, tag VARCHAR(20))",
"INSERT INTO oi_dump_src.items VALUES (1, 'dumped')",
] {
db.execute("m", stmt, 1, &c).await?;
}
let file = tmp.path().join("src.sql").to_string_lossy().into_owned();
let run = |executable: String, job: DbToolJob| {
let db = &db;
async move {
let mut lines = Vec::new();
let code =
db.run_tool("m", executable.as_ref(), &job, &CancellationToken::new(), |b| lines.extend(b)).await?;
assert_eq!(code, Some(0), "{} failed: {lines:?}", job.tool().program());
IdeResult::Ok(())
}
};
let masking = ide_db::tools::options_of(dump.path.as_ref())?.iter().any(|o| o == "masking-policies");
let options = DbMysqldumpOptions {
databases: vec!["oi_dump_src".into()],
tables: vec![],
add_drop_table: true,
disable_keys: true,
add_locks: true,
add_drop_trigger: false,
no_data: false,
complete_insert: false,
create_options: true,
routines: false,
events: false,
single_transaction: true,
lock_all_tables: false,
masking_policies: masking.then_some(false),
};
run(dump.path.clone(), DbToolJob::Mysqldump { file: file.clone(), options: options.clone() }).await?;
assert!(!ide_db::tools::dump_info(file.as_ref())?.creates_database, "one database: restored into a chosen one");
let both = tmp.path().join("both.sql").to_string_lossy().into_owned();
let two = DbMysqldumpOptions { databases: vec!["oi_dump_src".into(), "oi_dump_dst".into()], ..options };
run(dump.path, DbToolJob::Mysqldump { file: both.clone(), options: two }).await?;
assert!(ide_db::tools::dump_info(both.as_ref())?.creates_database, "several databases: created by the dump");
let restore = DbMysqlOptions { database: "oi_dump_dst".into(), force: false };
run(client.path, DbToolJob::Mysql { file, options: restore }).await?;
let r = db.execute("m", "SELECT tag FROM oi_dump_dst.items", 1, &c).await?;
assert_eq!(r.rows[0][0].as_deref(), Some("dumped"));
for stmt in ["DROP DATABASE oi_dump_src", "DROP DATABASE oi_dump_dst"] {
db.execute("m", stmt, 1, &c).await?;
}
Ok(())
}
+1
Переглянути файл
@@ -282,6 +282,7 @@ async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> {
let restore = DbPgRestoreOptions {
content: DbDumpContent::All,
schemas: vec![],
create: false,
clean: false,
if_exists: false,
no_owner: false,
+1 -1
Переглянути файл
@@ -142,7 +142,7 @@ pub fn snapshot(ep: &DockerEndpoint) -> DockerSnapshot {
}
const FMT: &str = "{{json .}}";
let (containers, images, volumes, networks) = std::thread::scope(|s| {
let c = s.spawn(|| run(ep, &["ps", "--all", "--no-trunc", "--format", FMT], QUICK));
let c = s.spawn(|| run(ep, &["ps", "--all", "--no-trunc", "--format", PS_FORMAT], QUICK));
let i = s.spawn(|| run(ep, &["image", "ls", "--no-trunc", "--format", FMT], QUICK));
let v = s.spawn(|| run(ep, &["volume", "ls", "--format", FMT], QUICK));
let n = s.spawn(|| run(ep, &["network", "ls", "--no-trunc", "--format", FMT], QUICK));
+11 -1
Переглянути файл
@@ -226,6 +226,16 @@ fn lines<T: for<'de> Deserialize<'de>>(text: &str) -> impl Iterator<Item = T> +
})
}
/// The `docker ps --format` template: only the fields [`RawContainer`] reads. `{{json .}}`
/// would also include `Size`, which makes the daemon compute every container's writable
/// layer and can take tens of seconds.
pub const PS_FORMAT: &str = concat!(
r#"{"ID":{{json .ID}},"Names":{{json .Names}},"Image":{{json .Image}},"#,
r#""Command":{{json .Command}},"State":{{json .State}},"Status":{{json .Status}},"#,
r#""Ports":{{json .Ports}},"CreatedAt":{{json .CreatedAt}},"Labels":{{json .Labels}},"#,
r#""Mounts":{{json .Mounts}},"Networks":{{json .Networks}}}"#,
);
#[derive(Deserialize, Default)]
#[serde(rename_all = "PascalCase", default)]
struct RawContainer {
@@ -247,7 +257,7 @@ fn split_csv(raw: &str) -> Vec<String> {
raw.split(',').map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned).collect()
}
/// `docker ps -a --no-trunc --format '{{json .}}'`.
/// `docker ps -a --no-trunc --format` [`PS_FORMAT`] (or `'{{json .}}'`).
pub fn parse_containers(text: &str) -> Vec<DockerContainer> {
let mut out: Vec<DockerContainer> = lines::<RawContainer>(text)
.map(|r| {
+23 -2
Переглянути файл
@@ -1,8 +1,8 @@
//! Parsing of recorded `docker … --format '{{json .}}'` output.
use ide_docker::{
parse_container_stats, parse_container_top, parse_containers, parse_image_history, parse_images, parse_networks,
parse_volumes,
PS_FORMAT, parse_container_stats, parse_container_top, parse_containers, parse_image_history, parse_images,
parse_networks, parse_volumes,
};
const PS: &str = include_str!("fixtures/ps.jsonl");
@@ -10,6 +10,27 @@ const IMAGES: &str = include_str!("fixtures/images.jsonl");
const VOLUMES: &str = include_str!("fixtures/volumes.jsonl");
const NETWORKS: &str = include_str!("fixtures/networks.jsonl");
/// Fills `{{json .Field}}` placeholders of a `--format` template from a `{{json .}}` line.
fn render(template: &str, line: &str) -> String {
let fields: serde_json::Map<String, serde_json::Value> = serde_json::from_str(line).unwrap();
let mut out = template.to_owned();
while let Some(start) = out.find("{{json .") {
let end = start + out[start..].find("}}").unwrap() + 2;
let key = &out[start + "{{json .".len()..end - 2];
let value = fields.get(key).unwrap_or_else(|| panic!("fixture lacks {key}"));
out.replace_range(start..end, &value.to_string());
}
out
}
#[test]
fn ps_format_carries_everything_the_parser_reads_but_size() {
assert!(!PS_FORMAT.contains("Size"), "Size makes the daemon compute container sizes");
let rendered: Vec<String> = PS.lines().filter(|l| l.starts_with('{')).map(|l| render(PS_FORMAT, l)).collect();
assert_eq!(rendered.len(), 2);
assert_eq!(parse_containers(&rendered.join("\n")), parse_containers(PS));
}
#[test]
fn containers_with_compose_labels() {
let c = parse_containers(PS);
+12 -1
Переглянути файл
@@ -38,6 +38,8 @@ pub enum Capability {
InputEvents,
/// The system clipboard, from the plugin's web views.
Clipboard,
/// Read the clipboard from commands and view actions the user ran (API 1.11).
ClipboardRead,
/// HTTPS (and loopback HTTP) to one host (`*.example.com` matches subdomains).
Net(String),
/// Ask the user when the first request goes to an HTTPS (or loopback) host
@@ -88,7 +90,8 @@ impl Capability {
| Self::NetHttp(_)
| Self::Secrets
| Self::InputEvents
| Self::Clipboard => Risk::Medium,
| Self::Clipboard
| Self::ClipboardRead => Risk::Medium,
// A trusted project's own files name the programs the IDE starts (its settings, its
// build scripts), so writing them is running code.
Self::ProjectWrite
@@ -127,6 +130,7 @@ impl Capability {
Self::Clipboard => {
"Copy to the clipboard from its commands, and read and write it from its web views".into()
}
Self::ClipboardRead => "Read the clipboard's text and images when you run one of its commands".into(),
Self::Net(host) => format!("Connect to {host} (from the machine the project is on)"),
Self::NetAsk => {
"Ask to connect to a host that is not on the list the first time it tries; you allow or refuse each host, and can revoke the allowed ones"
@@ -262,6 +266,7 @@ impl fmt::Display for Capability {
Self::Events => f.write_str("events"),
Self::InputEvents => f.write_str("events.input"),
Self::Clipboard => f.write_str("clipboard"),
Self::ClipboardRead => f.write_str("clipboard.read"),
Self::Net(h) => write!(f, "net:{h}"),
Self::NetAsk => f.write_str("net:ask"),
Self::NetHttp(h) => write!(f, "net.http:{h}"),
@@ -348,6 +353,7 @@ impl FromStr for Capability {
"events" => Self::Events,
"events.input" => Self::InputEvents,
"clipboard" => Self::Clipboard,
"clipboard.read" => Self::ClipboardRead,
"java.agent" => Self::JavaAgent,
_ => return Err(format!("unknown capability {s:?}")),
})
@@ -398,6 +404,7 @@ mod tests {
"project.write",
"vcs.write",
"build.read",
"clipboard.read",
"storage",
"secrets",
"events",
@@ -439,6 +446,10 @@ mod tests {
assert_eq!(Capability::InputEvents.risk(), Risk::Medium);
assert_eq!("clipboard".parse::<Capability>().unwrap(), Capability::Clipboard);
assert_eq!(Capability::Clipboard.risk(), Risk::Medium);
// Reading is its own grant: neither clipboard capability covers the other.
assert_eq!(Capability::ClipboardRead.risk(), Risk::Medium);
assert!(!Capability::Clipboard.covers(&Capability::ClipboardRead));
assert!(!Capability::ClipboardRead.covers(&Capability::Clipboard));
assert_eq!(Capability::Process("cargo".into()).risk(), Risk::High);
assert_eq!(Capability::Lsp("phoxite".into()).risk(), Risk::High);
assert_eq!(Capability::BuildRead.risk(), Risk::Low);
+12 -1
Переглянути файл
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
pub const MANIFEST_FILE: &str = "plugin.toml";
/// The plugin API (engine) version this host implements.
pub const ENGINE_VERSION: &str = "1.10.0";
pub const ENGINE_VERSION: &str = "1.11.0";
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
pub const LEGACY_API: &str = "0.1";
/// Marketplace categories, in the order they are shown.
@@ -363,6 +363,9 @@ impl Manifest {
if matches!(cap, Capability::BuildRead) {
self.needs_api(&format!("capability `{cap}`"), 10)?;
}
if matches!(cap, Capability::ClipboardRead) {
self.needs_api(&format!("capability `{cap}`"), 11)?;
}
if matches!(cap, Capability::JavaAgent) {
return Err(
"`java.agent` comes from `[[contributes.javaAgents]]`: remove it from [capabilities]".into()
@@ -746,6 +749,14 @@ required = [\"lsp:phoxite\"]
assert_eq!(m.capabilities.optional, [Capability::BuildRead]);
}
#[test]
fn the_clipboard_read_capability_needs_api_1_11() {
let caps = "[capabilities]\noptional = [\"clipboard.read\"]\n";
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).contains("new in plugin API 1.11"));
let m = Manifest::parse(&format!("{}{caps}", BASE.replace("^1.2", "^1.11"))).unwrap();
assert_eq!(m.capabilities.optional, [Capability::ClipboardRead]);
}
#[test]
fn java_agent_capability_is_not_declared() {
for list in ["required", "optional"] {
+426
Переглянути файл
@@ -0,0 +1,426 @@
//! The project's direnv environment: when the project root has an `.envrc`, `direnv export
//! json` runs there and every child started in the project gets what it exports
//! ([`ide_core::project_env`]): terminals, runs, language servers (which wait for it), build
//! tools and debuggers, locally and on a remote host alike. An `.envrc` with `use flake`
//! loads a Nix flake's devshell this way.
//!
//! `.envrc` is project code: it runs in trusted projects only, and only once the user
//! allowed it with `direnv allow`, which the IDE never does for them.
use ide_core::event::DirenvStatus;
use ide_core::{CancellationToken, IdeEvent, SharedSink, TaskId};
use std::collections::BTreeMap;
use std::ffi::OsString;
use std::io::{BufRead, BufReader, Read};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::mpsc::RecvTimeoutError;
use std::time::{Duration, Instant};
pub(crate) const ENVRC: &str = ".envrc";
/// Files in the project root whose change offers a reload: the `.envrc` and the flake
/// `use flake` evaluates.
const WATCHED: [&str; 3] = [ENVRC, "flake.nix", "flake.lock"];
/// A cold `use flake` builds or downloads the devshell: minutes, not seconds.
pub(crate) const TIMEOUT: Duration = Duration::from_secs(10 * 60);
/// Output lines kept for a failure's notification.
const TAIL_LINES: usize = 12;
pub(crate) type Changes = Vec<(OsString, Option<OsString>)>;
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum Failure {
/// The user hasn't allowed this `.envrc` (`direnv allow`).
Blocked,
Failed(String),
Cancelled,
}
pub(crate) fn has_envrc(root: &Path) -> bool {
root.join(ENVRC).is_file()
}
/// `direnv` on the IDE's search path.
pub(crate) fn program() -> Option<PathBuf> {
ide_core::process::find_executable("direnv", &ide_core::tool_path::search_path())
}
/// The watched file among `paths` (changed or removed below `root`), when the project has an
/// `.envrc` or just lost it: what a reload would pick up.
pub(crate) fn reload_offer<'a>(root: &Path, paths: impl IntoIterator<Item = &'a PathBuf>) -> Option<String> {
let file = paths
.into_iter()
.filter(|p| p.parent() == Some(root))
.filter_map(|p| p.file_name()?.to_str())
.find(|name| WATCHED.contains(name))?;
(file == ENVRC || has_envrc(root)).then(|| file.to_owned())
}
/// Runs `program export json` in `root` from the environment children outside any project
/// get (not the project's last one: a reload must not see its own result), reporting
/// direnv's progress lines to `on_line`. Gives up after `timeout` or once `cancel` fires,
/// stopping what direnv started (`nix`) too.
pub(crate) fn export(
program: &Path,
root: &Path,
timeout: Duration,
cancel: &CancellationToken,
on_line: &dyn Fn(&str),
) -> Result<Changes, Failure> {
let mut cmd = Command::new(program);
ide_core::process::prepare(ide_core::process::own_group(&mut cmd));
let mut child = cmd
.args(["export", "json"])
.current_dir(root)
.env_clear()
.envs(ide_core::process::host_vars())
.envs(ide_core::process::shell_env())
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| Failure::Failed(format!("cannot start {}: {e}", program.display())))?;
let mut stdout = child.stdout.take().expect("piped");
let out = std::thread::spawn(move || {
let mut buf = Vec::new();
stdout.read_to_end(&mut buf).map(|_| buf)
});
let (tx, rx) = std::sync::mpsc::channel::<String>();
let stderr = child.stderr.take().expect("piped");
std::thread::spawn(move || {
for line in BufReader::new(stderr).split(b'\n').map_while(Result::ok) {
let line = ide_core::output_encoding::decode_tool_output(&line).trim_end_matches('\r').to_owned();
if tx.send(line).is_err() {
break;
}
}
});
let deadline = Instant::now() + timeout;
let mut tail: Vec<String> = Vec::new();
let mut keep = |line: String| {
on_line(&line);
tail.push(line);
let excess = tail.len().saturating_sub(TAIL_LINES);
tail.drain(..excess);
};
loop {
if cancel.is_cancelled() {
ide_core::process::kill_tree(&mut child);
return Err(Failure::Cancelled);
}
if Instant::now() > deadline {
ide_core::process::kill_tree(&mut child);
return Err(Failure::Failed(format!(
"direnv did not finish within {} minutes.\n\n{}",
timeout.as_secs() / 60,
tail.join("\n")
)));
}
match rx.recv_timeout(Duration::from_millis(50)) {
Ok(line) => keep(line),
Err(RecvTimeoutError::Timeout) => {}
Err(RecvTimeoutError::Disconnected) => break,
}
}
let status = child.wait().map_err(|e| Failure::Failed(e.to_string()))?;
let stdout = out.join().ok().and_then(Result::ok).unwrap_or_default();
if tail.iter().any(|l| l.contains("is blocked") || l.contains("is not allowed")) {
return Err(Failure::Blocked);
}
if !status.success() {
let tail = tail.join("\n");
return Err(Failure::Failed(if tail.is_empty() { format!("direnv exited with {status}") } else { tail }));
}
parse(&stdout).map_err(Failure::Failed)
}
/// `direnv export json`'s output: the variables to set, `null` for those to unset; nothing
/// when there is nothing to change.
fn parse(stdout: &[u8]) -> Result<Changes, String> {
if stdout.iter().all(u8::is_ascii_whitespace) {
return Ok(Changes::new());
}
let vars: BTreeMap<String, Option<String>> =
serde_json::from_slice(stdout).map_err(|e| format!("unexpected output from direnv: {e}"))?;
Ok(vars.into_iter().map(|(k, v)| (k.into(), v.map(Into::into))).collect())
}
/// Loads `root`'s environment with `program` (`None`: direnv isn't installed) into
/// [`ide_core::project_env`], as a cancellable background task; what went wrong is a
/// [`IdeEvent::Direnv`]. `current` says whether this load still owns `root` (not closed or
/// superseded by a newer one meanwhile) and is checked again before anything is applied.
pub(crate) fn load(
root: &Path,
program: Option<&Path>,
sink: &SharedSink,
cancel: &CancellationToken,
timeout: Duration,
hint_missing: bool,
current: &dyn Fn(&dyn Fn()),
) {
let report = |status: DirenvStatus| sink.emit(IdeEvent::Direnv { root: root.to_path_buf().into(), status });
let Some(program) = program else {
current(&|| ide_core::project_env::settle(root));
if hint_missing {
report(DirenvStatus::NotInstalled);
}
return;
};
let task = TaskId::next();
let _cancel_handle = ide_core::task::on_cancel(task, {
let cancel = cancel.clone();
move || cancel.cancel()
});
let progress = |message: Option<String>, done: bool| {
sink.emit(IdeEvent::Task {
id: task,
title: "Loading the direnv environment".into(),
message,
fraction: None,
done,
cancellable: !done,
});
};
progress(Some(format!("{} export json", program.display())), false);
let result = export(program, root, timeout, cancel, &|line| progress(Some(line.to_owned()), false));
progress(None, true);
match result {
Ok(changes) => {
tracing::info!("direnv: {} variables for {}", changes.len(), root.display());
current(&|| ide_core::project_env::set(root, changes.clone()));
}
Err(Failure::Blocked) => {
// As in a shell: a blocked `.envrc` isn't loaded.
current(&|| ide_core::project_env::set(root, Changes::new()));
report(DirenvStatus::Blocked);
}
Err(Failure::Failed(message)) => {
tracing::warn!("direnv in {}: {message}", root.display());
current(&|| ide_core::project_env::settle(root));
report(DirenvStatus::Failed { message });
}
// Closed or superseded (that one settles), or stopped from the task list.
Err(Failure::Cancelled) => current(&|| ide_core::project_env::settle(root)),
}
}
#[cfg(all(test, unix))]
mod tests {
use super::*;
use ide_core::EventSink;
use parking_lot::Mutex;
use std::os::unix::fs::PermissionsExt;
use std::sync::Arc;
/// A stand-in `direnv`: checks its arguments, then prints `stderr` and `out.json` of the
/// folder it runs in and exits with `code`, or blocks like direnv on an `.envrc` not allowed.
fn fake_direnv(dir: &Path) -> PathBuf {
let program = dir.join("direnv");
std::fs::write(
&program,
r#"#!/bin/sh
[ "$1 $2" = "export json" ] || { echo "direnv: unexpected arguments $*" >&2; exit 2; }
echo "direnv: loading $PWD/.envrc" >&2
[ -f slow ] && sleep 30
[ -f blocked ] && { echo "direnv: error $PWD/.envrc is blocked. Run \`direnv allow\` to approve its content" >&2; exit 1; }
[ -f stderr ] && cat stderr >&2
[ -f out.json ] && cat out.json
echo "direnv: export +NIX_DEV" >&2
exit "$(cat code 2>/dev/null || echo 0)"
"#,
)
.unwrap();
std::fs::set_permissions(&program, std::fs::Permissions::from_mode(0o755)).unwrap();
program
}
fn project() -> (tempfile::TempDir, PathBuf, PathBuf) {
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap().join("project");
std::fs::create_dir(&root).unwrap();
std::fs::write(root.join(ENVRC), "use flake\n").unwrap();
let program = fake_direnv(tmp.path());
(tmp, root, program)
}
fn run(program: &Path, root: &Path) -> (Result<Changes, Failure>, Vec<String>) {
let lines = Mutex::new(Vec::new());
let result = export(program, root, Duration::from_secs(20), &CancellationToken::new(), &|l| {
lines.lock().push(l.to_owned())
});
(result, lines.into_inner())
}
fn change(k: &str, v: Option<&str>) -> (OsString, Option<OsString>) {
(k.into(), v.map(Into::into))
}
#[test]
fn exported_variables_are_set_and_unset() {
let (_tmp, root, program) = project();
std::fs::write(
root.join("out.json"),
r#"{"PATH":"/nix/store/abc-devshell/bin:/usr/bin","IN_NIX_SHELL":"impure","OLD":null}"#,
)
.unwrap();
let (result, lines) = run(&program, &root);
assert_eq!(
result.unwrap(),
[
change("IN_NIX_SHELL", Some("impure")),
change("OLD", None),
change("PATH", Some("/nix/store/abc-devshell/bin:/usr/bin")),
]
);
assert_eq!(lines, [format!("direnv: loading {}/.envrc", root.display()), "direnv: export +NIX_DEV".into()]);
}
#[test]
fn nothing_to_export_changes_nothing() {
let (_tmp, root, program) = project();
assert_eq!(run(&program, &root).0, Ok(Changes::new()));
}
#[test]
fn a_blocked_envrc_is_reported_as_such() {
let (_tmp, root, program) = project();
std::fs::write(root.join("blocked"), "").unwrap();
assert_eq!(run(&program, &root).0, Err(Failure::Blocked));
}
#[test]
fn a_failure_reports_the_end_of_the_output() {
let (_tmp, root, program) = project();
std::fs::write(root.join("stderr"), "error: flake 'path:/p' does not provide attribute 'devShells'\n").unwrap();
std::fs::write(root.join("code"), "1").unwrap();
let Err(Failure::Failed(message)) = run(&program, &root).0 else { panic!("a failure") };
assert!(message.contains("does not provide attribute 'devShells'"), "{message}");
std::fs::remove_file(root.join("code")).unwrap();
std::fs::write(root.join("out.json"), "not json").unwrap();
let Err(Failure::Failed(message)) = run(&program, &root).0 else { panic!("a failure") };
assert!(message.starts_with("unexpected output from direnv"), "{message}");
}
#[test]
fn a_slow_direnv_times_out_or_is_cancelled() {
let (_tmp, root, program) = project();
std::fs::write(root.join("slow"), "").unwrap();
let started = Instant::now();
let result = export(&program, &root, Duration::from_secs(2), &CancellationToken::new(), &|_| {});
let Err(Failure::Failed(message)) = result else { panic!("a timeout") };
assert!(message.starts_with("direnv did not finish within"), "{message}");
assert!(message.contains("direnv: loading"), "{message}");
let cancel = CancellationToken::new();
let c = cancel.clone();
std::thread::spawn(move || {
std::thread::sleep(Duration::from_millis(200));
c.cancel();
});
assert_eq!(export(&program, &root, Duration::from_secs(60), &cancel, &|_| {}), Err(Failure::Cancelled));
assert!(started.elapsed() < Duration::from_secs(20));
}
#[test]
fn missing_program_is_a_start_failure() {
let (_tmp, root, _) = project();
let Err(Failure::Failed(message)) = run(Path::new("/openidea-no-such/direnv"), &root).0 else { panic!() };
assert!(message.starts_with("cannot start"), "{message}");
}
#[derive(Default)]
struct Events(Mutex<Vec<IdeEvent>>);
impl EventSink for Events {
fn emit(&self, e: IdeEvent) {
self.0.lock().push(e);
}
}
fn statuses(events: &Events) -> Vec<DirenvStatus> {
events
.0
.lock()
.iter()
.filter_map(|e| match e {
IdeEvent::Direnv { status, .. } => Some(status.clone()),
_ => None,
})
.collect()
}
fn load_with(root: &Path, program: Option<&Path>, hint: bool) -> Arc<Events> {
let events = Arc::new(Events::default());
let sink: SharedSink = events.clone();
ide_core::project_env::begin_loading(root);
load(root, program, &sink, &CancellationToken::new(), Duration::from_secs(20), hint, &|apply| apply());
events
}
#[test]
fn children_in_the_project_get_what_direnv_exported() {
let (_tmp, root, program) = project();
std::fs::write(root.join("out.json"), r#"{"OPENIDEA_TEST_DEVSHELL":"1"}"#).unwrap();
let events = load_with(&root, Some(&program), true);
assert!(statuses(&events).is_empty());
assert!(!ide_core::project_env::is_loading(&root));
let mut cmd = Command::new("true");
cmd.current_dir(root.join("src"));
ide_core::process::host_env(&mut cmd);
assert!(cmd.get_envs().any(|(k, v)| k == "OPENIDEA_TEST_DEVSHELL" && v == Some("1".as_ref())));
// A task shows the progress, and ends.
let tasks: Vec<_> = events
.0
.lock()
.iter()
.filter_map(|e| match e {
IdeEvent::Task { message, done, .. } => Some((message.clone(), *done)),
_ => None,
})
.collect();
assert!(tasks.iter().any(|(m, _)| m.as_deref() == Some("direnv: export +NIX_DEV")), "{tasks:?}");
assert_eq!(tasks.last(), Some(&(None, true)));
// Blocked after an edit: the environment goes, as in a shell.
std::fs::write(root.join("blocked"), "").unwrap();
let events = load_with(&root, Some(&program), true);
assert_eq!(statuses(&events), [DirenvStatus::Blocked]);
assert!(ide_core::project_env::for_dir(&root).is_empty());
// A failure keeps the last environment and says why.
std::fs::remove_file(root.join("blocked")).unwrap();
load_with(&root, Some(&program), true);
std::fs::write(root.join("stderr"), "error: syntax error in flake.nix\n").unwrap();
std::fs::write(root.join("code"), "1").unwrap();
let events = load_with(&root, Some(&program), true);
let [DirenvStatus::Failed { message }] = &statuses(&events)[..] else { panic!("{:?}", statuses(&events)) };
assert!(message.contains("syntax error in flake.nix"), "{message}");
assert!(!ide_core::project_env::for_dir(&root).is_empty());
ide_core::project_env::remove(&root);
}
#[test]
fn direnv_not_installed_is_hinted_once_and_does_not_block() {
let (_tmp, root, _) = project();
let events = load_with(&root, None, true);
assert_eq!(statuses(&events), [DirenvStatus::NotInstalled]);
assert!(!ide_core::project_env::is_loading(&root), "language servers start anyway");
assert!(statuses(&load_with(&root, None, false)).is_empty());
ide_core::project_env::remove(&root);
}
#[test]
fn changes_to_the_envrc_or_flake_offer_a_reload() {
let (_tmp, root, _) = project();
let paths = |names: &[&str]| names.iter().map(|n| root.join(n)).collect::<Vec<_>>();
assert_eq!(reload_offer(&root, &paths(&["src/main.rs", "flake.lock"])), Some("flake.lock".into()));
assert_eq!(reload_offer(&root, &paths(&[".envrc"])), Some(".envrc".into()));
assert_eq!(reload_offer(&root, &paths(&["sub/flake.nix", "src/main.rs"])), None, "the project root's only");
std::fs::remove_file(root.join(ENVRC)).unwrap();
assert_eq!(reload_offer(&root, &paths(&["flake.nix"])), None, "no .envrc: nothing loads the flake");
assert_eq!(reload_offer(&root, &paths(&[".envrc"])), Some(".envrc".into()), "removed: reload unloads");
}
}
+92 -11
Переглянути файл
@@ -1,9 +1,11 @@
//! The environment child processes get beyond this process's own: the login shell's as
//! re-read by Reload Environment, and (remote server) the project's
//! `devcontainer.json` `remoteEnv`, plus its `postStartCommand` once per server start.
//! re-read by Reload Environment, (remote server) the project's `devcontainer.json`
//! `remoteEnv`, plus its `postStartCommand` once per server start, and each trusted
//! project's direnv `.envrc` ([`crate::direnv`]).
//!
//! Both reach every child through `ide_core::process::set_env_overlay`: terminals, runs,
//! language servers, debug adapters, build tools and git all spawn through
//! The first two reach every child through `ide_core::process::set_env_overlay`, a project's
//! direnv environment the children started inside it (`ide_core::project_env`): terminals,
//! runs, language servers, debug adapters, build tools and git all spawn through
//! `ide_core::process::prepare` / `host_env`.
use ide_core::event::NotifyLevel;
@@ -18,6 +20,7 @@ use std::io::{BufRead, BufReader, Read};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::time::Duration;
type Changes = Vec<(OsString, Option<OsString>)>;
@@ -51,18 +54,87 @@ struct State {
post_commands: std::collections::HashMap<PathBuf, CancellationToken>,
}
/// Project roots whose direnv environment is loaded or loading, with the load that owns
/// each (a generation) and what stops it.
type DirenvLoads = Arc<Mutex<std::collections::HashMap<PathBuf, (u64, CancellationToken)>>>;
pub struct Environment {
/// Whether the open project's `devcontainer.json` applies (the remote server: one project per process).
project_env: bool,
data_dir: PathBuf,
state: Mutex<State>,
/// Stops running `postStartCommand`s when the host shuts down.
/// Stops running `postStartCommand`s and direnv loads when the host shuts down.
cancel: CancellationToken,
direnv: DirenvLoads,
/// "direnv is not installed" is said once per process.
direnv_hinted: AtomicBool,
}
impl Environment {
pub(crate) fn new(project_env: bool, data_dir: PathBuf) -> Self {
Self { project_env, data_dir, state: Mutex::default(), cancel: CancellationToken::new() }
Self {
project_env,
data_dir,
state: Mutex::default(),
cancel: CancellationToken::new(),
direnv: DirenvLoads::default(),
direnv_hinted: AtomicBool::new(false),
}
}
/// A trusted project at `root` opened or became trusted: loads its direnv environment in
/// the background, unless another window of it already did. Its language servers wait.
pub(crate) fn direnv_opened(&self, root: &Path, sink: &SharedSink) {
if !self.direnv.lock().contains_key(root) {
self.load_direnv(root, sink, true);
}
}
/// The project at `root` closed in its last window, or is no longer trusted.
pub(crate) fn direnv_closed(&self, root: &Path) {
if let Some((_, cancel)) = self.direnv.lock().remove(root) {
cancel.cancel();
}
ide_core::project_env::remove(root);
}
/// (Re)loads `root`'s direnv environment, replacing a load still running; on this thread
/// unless `background`. Without an `.envrc` the project has none.
fn load_direnv(&self, root: &Path, sink: &SharedSink, background: bool) {
static GENERATION: AtomicU64 = AtomicU64::new(0);
let generation = GENERATION.fetch_add(1, Ordering::Relaxed);
let cancel = self.cancel.child_token();
{
let mut loads = self.direnv.lock();
if let Some((_, previous)) = loads.insert(root.to_path_buf(), (generation, cancel.clone())) {
previous.cancel();
}
if !crate::direnv::has_envrc(root) {
ide_core::project_env::remove(root);
return;
}
// Before this returns: a language server starting next waits for it.
ide_core::project_env::begin_loading(root);
}
let program = crate::direnv::program();
let hint = program.is_none() && !self.direnv_hinted.swap(true, Ordering::AcqRel);
let (loads, dir, sink) = (self.direnv.clone(), root.to_path_buf(), sink.clone());
let run = move || {
let current = |apply: &dyn Fn()| {
let loads = loads.lock();
if loads.get(&dir).is_some_and(|(g, _)| *g == generation) {
apply();
}
};
crate::direnv::load(&dir, program.as_deref(), &sink, &cancel, crate::direnv::TIMEOUT, hint, &current);
};
if !background {
run();
} else if let Err(e) = std::thread::Builder::new().name("openidea-direnv".into()).spawn(run) {
tracing::warn!("direnv: {e}");
// Language servers must not wait for a load that never runs.
ide_core::project_env::settle(root);
}
}
pub(crate) fn shutdown(&self) {
@@ -118,11 +190,17 @@ impl Environment {
ide_core::process::set_env_overlay(merge(&state.login, &state.project));
}
/// Reload Environment: reads the login shell again and re-applies the project's
/// `remoteEnv` (`root`). Blocking (it runs the shell); children already running keep
/// their environment.
/// Reload Environment: reads the login shell again, re-applies the project's `remoteEnv`
/// and loads its direnv environment again (`root`, a trusted project). Blocking (it runs
/// the shell and direnv); children already running keep their environment.
pub fn reload(&self, root: Option<&Path>, sink: &SharedSink) -> IdeResult<EnvReloaded> {
let before: Vec<_> = ide_core::process::host_vars().collect();
let vars = || -> Vec<_> {
match root {
Some(root) => ide_core::process::host_vars_in(root).collect(),
None => ide_core::process::host_vars().collect(),
}
};
let before = vars();
let fresh = crate::shell_env::read_login_env_now().map_err(IdeError::unavailable)?;
let shell_read = fresh.is_some();
if let Some(fresh) = fresh {
@@ -146,7 +224,10 @@ impl Environment {
None
}
};
let after: Vec<_> = ide_core::process::host_vars().collect();
if let Some(root) = root {
self.load_direnv(root, sink, false);
}
let after = vars();
Ok(EnvReloaded { changed: changed_names(&before, &after), devcontainer, shell_read })
}
+4
Переглянути файл
@@ -7,6 +7,7 @@ pub mod agent_secrets;
pub mod catalogue;
pub mod data_dirs;
pub mod diagnostics_store;
mod direnv;
pub mod environment;
mod formatter;
mod java_runtime;
@@ -318,6 +319,9 @@ impl Host {
}
if !project.light {
self.environment.project_closed();
if self.windows_for_root(&project.root).is_empty() {
self.environment.direnv_closed(&project.root);
}
}
if let Some(bridge) = &project.kotlin_bridge {
bridge.stop();
+1
Переглянути файл
@@ -40,6 +40,7 @@ fn tools() -> Vec<tool::Tool> {
tools.push(check::check_files());
tools.push(symbols::get_symbol_info());
tools.push(symbols::find_references());
tools.push(symbols::get_call_hierarchy());
tools.extend(edit::tools());
tools.extend(run::tools());
tools.extend(vcs::tools());
+1 -1
Переглянути файл
@@ -280,7 +280,7 @@ fn context(call: &Call) -> IdeResult<(u32, u32)> {
/// `line`, or when longer than [`MAX_LINE_TEXT`] UTF-16 units, the part from [`SNIPPET_AROUND`]
/// units before 0-based UTF-16 column `start` to as many after `end`, with `…` where it was cut.
fn snippet(line: &str, start: usize, end: usize) -> String {
pub(super) fn snippet(line: &str, start: usize, end: usize) -> String {
let units: usize = line.chars().map(char::len_utf16).sum();
if units <= MAX_LINE_TEXT {
return line.to_owned();
+422 -22
Переглянути файл
@@ -1,10 +1,13 @@
//! Quick Documentation through the project's language services.
use super::tool::{Call, Output, Param, ParamType, Tool};
use ide_core::{IdeError, IdeResult, Pos, Range};
use ide_lsp::types::GotoKind;
use ide_core::error::ErrorKind;
use ide_core::{DocId, IdeError, IdeResult, OutlineItem, Pos, Range, RequestId, SymbolKind};
use ide_lsp::types::{CallHierarchy, GotoKind, HierarchyDirection, HierarchyItem, ReferencesIncomplete};
use serde::Serialize;
use serde_json::json;
use std::path::Path;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::Duration;
pub fn get_symbol_info() -> Tool {
Tool::new("get_symbol_info", "Retrieves information about the symbol at the specified position in the specified file.
@@ -212,26 +215,10 @@ pub fn find_references() -> Tool {
let path = call.resolve_readable(&call.str("filePath")?).await?;
let page = super::page::Page::of(&call, REFERENCES_LIMIT)?;
let dir = super::scope::Scope::of(&call)?;
let line = call.opt_i64("line")?.ok_or_else(|| IdeError::invalid("missing line"))?;
let column = call.opt_i64("column")?.ok_or_else(|| IdeError::invalid("missing column"))?;
let project = call.project.clone();
let (doc, text) = call.host.blocking(move || {
let text = project.text_of(&path)?;
let doc = project.documents.open(&path)?;
Ok((doc.id, text))
}).await?;
struct Close(std::sync::Arc<crate::Project>, ide_core::DocId);
impl Drop for Close { fn drop(&mut self) { self.0.documents.close(self.1); } }
let _close = Close(call.project.clone(), doc);
let pos = mcp_position(&text, line, column)?;
let opened = open_at(&call, path).await?;
let request = super::tool::request_id();
let work = crate::ops::lsp::lsp_references(&call.host, &call.window, request, doc, pos, call.flag("includeDeclaration", true)?, true, false, crate::ops::Channel::new(|_| {}));
tokio::pin!(work);
let result = tokio::select! {
result = &mut work => result?,
_ = call.cancel.cancelled() => { call.host.cancel_request(request); let _ = work.await; return Err(IdeError::cancelled()); }
_ = tokio::time::sleep(std::time::Duration::from_secs(60)) => { call.host.cancel_request(request); let _ = work.await; return Err(IdeError::unavailable("references timed out; retry when analysis finishes")); }
};
let work = crate::ops::lsp::lsp_references(&call.host, &call.window, request, opened.doc, opened.pos, call.flag("includeDeclaration", true)?, true, false, crate::ops::Channel::new(|_| {}));
let result = race(&call, request, work, "references timed out; retry when analysis finishes").await?;
let mut value = serde_json::to_value(&result).map_err(|e| IdeError::internal(e.to_string()))?;
// Convert every Location range at this boundary, including declarations.
fn positions(value: &mut serde_json::Value) {
@@ -274,6 +261,266 @@ pub fn find_references() -> Tool {
/// References `find_references` lists by default.
const REFERENCES_LIMIT: usize = 100;
/// A document a tool opened for the language services and the position it asked about;
/// dropping it closes the document.
#[must_use]
struct Opened {
project: Arc<crate::Project>,
doc: DocId,
pos: Pos,
}
impl Drop for Opened {
fn drop(&mut self) {
self.project.documents.close(self.doc);
}
}
/// Opens `path` at the call's 1-based `line` and `column`.
async fn open_at(call: &Call, path: PathBuf) -> IdeResult<Opened> {
let line = call.opt_i64("line")?.ok_or_else(|| IdeError::invalid("missing line"))?;
let column = call.opt_i64("column")?.ok_or_else(|| IdeError::invalid("missing column"))?;
let project = call.project.clone();
let (doc, text) = call
.host
.blocking(move || {
let text = project.text_of(&path)?;
let doc = project.documents.open(&path)?;
Ok((doc.id, text))
})
.await?;
let mut opened = Opened { project: call.project.clone(), doc, pos: Pos::default() };
opened.pos = mcp_position(&text, line, column)?;
Ok(opened)
}
/// How long a tool waits for a language service request.
const LANGUAGE_SERVICE_TIMEOUT: Duration = Duration::from_secs(60);
/// `work`, the language service `request`, until it ends; when the client cancels or
/// [`LANGUAGE_SERVICE_TIMEOUT`] passes first, the request is cancelled and `work` runs to its end.
async fn race<T>(
call: &Call,
request: RequestId,
work: impl Future<Output = IdeResult<T>>,
timed_out: &'static str,
) -> IdeResult<T> {
tokio::pin!(work);
tokio::select! {
result = &mut work => result,
_ = call.cancel.cancelled() => {
call.host.cancel_request(request);
let _ = work.await;
Err(IdeError::cancelled())
}
_ = tokio::time::sleep(LANGUAGE_SERVICE_TIMEOUT) => {
call.host.cancel_request(request);
let _ = work.await;
Err(IdeError::unavailable(timed_out))
}
}
}
pub fn get_call_hierarchy() -> Tool {
Tool::new(
"get_call_hierarchy",
"Callers (incoming) or callees (outgoing) of the function or method at the position, from \
the language server's call hierarchy. A position inside a function body means that function. \
One level per call: to go deeper, call again with an item's filePath, startLine and startColumn \
(items in libraries show a URI as filePath and cannot be expanded). \
Positions are 1-based UTF-16. `root` is the symbol the hierarchy is for; each item's callSites \
are where the call happens. Reports incomplete results when analysis is still running.",
call_hierarchy,
)
.param(Param::required("filePath", ParamType::String, "Path relative to the project root"))
.param(Param::required("line", ParamType::Integer, "1-based line"))
.param(Param::required("column", ParamType::Integer, "1-based UTF-16 column"))
.param(Param::optional("direction", ParamType::String, "incoming (callers, default) or outgoing (callees)"))
.param(super::scope::param())
.param(Param::optional("limit", ParamType::Integer, "Items to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
}
/// Items `get_call_hierarchy` lists by default.
const CALLS_LIMIT: usize = 100;
/// Call sites shown per item; `callSiteCount` gives the total when there are more.
const MAX_CALL_SITES: usize = 20;
const CALLS_TIMED_OUT: &str = "call hierarchy timed out; retry when analysis finishes";
async fn call_hierarchy(call: Call) -> IdeResult<Output> {
let direction = match call.opt_str("direction")?.as_deref() {
None | Some("incoming") => HierarchyDirection::Incoming,
Some("outgoing") => HierarchyDirection::Outgoing,
Some(_) => return Err(IdeError::invalid("direction must be incoming or outgoing")),
};
let page = super::page::Page::of(&call, CALLS_LIMIT)?;
let scope = super::scope::Scope::of(&call)?;
let path = call.resolve_readable(&call.str("filePath")?).await?;
let opened = open_at(&call, path).await?;
let hierarchy_at = |pos| {
let request = super::tool::request_id();
let work = crate::ops::lsp::lsp_call_hierarchy(&call.host, &call.window, request, opened.doc, pos, direction);
race(&call, request, work, CALLS_TIMED_OUT)
};
let mut found = match hierarchy_at(opened.pos).await {
// IDEA: inside a function body the hierarchy is the enclosing function's.
Err(e) if e.kind == ErrorKind::NotFound => {
let outline = tokio::select! {
outline = crate::ops::doc::doc_outline(&call.host, &call.window, opened.doc) => outline?,
_ = call.cancel.cancelled() => return Err(IdeError::cancelled()),
};
let at = enclosing_callable(&outline, opened.pos).map(|f| f.selection_range.start);
let Some(at) = at.filter(|at| *at != opened.pos) else {
let Pos { line, col } = opened.pos;
return Err(IdeError::not_found(format!("no function or method at {}:{}", line + 1, col + 1)));
};
hierarchy_at(at).await?
}
result => result?,
};
if scope.dir().is_some() {
found.items.retain(|i| i.uri.is_none() && scope.contains(&i.path.0));
}
let incomplete = found.incomplete;
let (mut root, items) = call_items(found, |p| call.display(p));
let mut out = serde_json::Map::new();
let mut items = page.take(items, &mut out);
// One file in memory at a time, as `search::fill_lines` reads them.
let mut places: Vec<&mut Place> = root
.iter_mut()
.chain(&mut items)
.flat_map(|i| std::iter::once(&mut i.at).chain(&mut i.call_sites))
.filter(|place| place.file.is_some())
.collect();
places.sort_by(|a, b| a.file.cmp(&b.file));
for in_file in places.chunk_by_mut(|a, b| a.file == b.file) {
if call.cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let Some(path) = in_file[0].file.clone() else { continue };
if let Ok(text) = crate::ops::fs::fs_read_text(&call.host, call.window(), path).await {
fill_line_texts(in_file, &text);
}
}
Output::json(CallHierarchyOutput { root, items, page: out, incomplete })
}
#[derive(Serialize)]
struct CallHierarchyOutput {
#[serde(skip_serializing_if = "Option::is_none")]
root: Option<CallItem>,
items: Vec<CallItem>,
/// `total`, and `more` and `nextOffset` when items follow.
#[serde(flatten)]
page: serde_json::Map<String, serde_json::Value>,
#[serde(skip_serializing_if = "Option::is_none")]
incomplete: Option<ReferencesIncomplete>,
}
/// A function or method in the call hierarchy, at its name.
#[derive(Serialize, Debug)]
#[serde(rename_all = "camelCase")]
struct CallItem {
name: String,
kind: SymbolKind,
#[serde(skip_serializing_if = "Option::is_none")]
detail: Option<String>,
#[serde(flatten)]
at: Place,
#[serde(skip_serializing_if = "Vec::is_empty")]
call_sites: Vec<Place>,
#[serde(skip_serializing_if = "Option::is_none")]
call_site_count: Option<usize>,
}
/// A range as the tools show it: 1-based UTF-16, with the text of its first line.
#[derive(Serialize, Debug)]
#[serde(rename_all = "camelCase")]
struct Place {
file_path: String,
start_line: u32,
start_column: u32,
end_line: u32,
end_column: u32,
#[serde(skip_serializing_if = "Option::is_none")]
line_text: Option<String>,
/// The file `line_text` is read from; none in a library.
#[serde(skip)]
file: Option<PathBuf>,
}
/// The root and the items of `h`, sorted by file and position, with call sites in source
/// order, at most [`MAX_CALL_SITES`] per item. Library items show their URI.
fn call_items(h: CallHierarchy, display: impl Fn(&Path) -> String) -> (Option<CallItem>, Vec<CallItem>) {
let CallHierarchy { root, items, .. } = h;
// A file path, or the URI of a virtual document, which has no lines to read here.
let target = |path: &Path, uri: Option<&String>| match uri {
Some(uri) => (None, uri.clone()),
None => (Some(path.to_path_buf()), display(path)),
};
let place = |(file, file_path): (Option<PathBuf>, String), r: Range| Place {
file_path,
start_line: r.start.line + 1,
start_column: r.start.col + 1,
end_line: r.end.line + 1,
end_column: r.end.col + 1,
line_text: None,
file,
};
let convert = |i: HierarchyItem| {
let at = target(&i.path.0, i.uri.as_ref());
let sites_in = match &i.from_path {
Some(p) => {
let shown = p.0.to_string_lossy();
target(&p.0, ide_core::is_virtual_uri(&shown).then(|| shown.into_owned()).as_ref())
}
None => at.clone(),
};
let mut sites = i.from_ranges;
sites.sort();
sites.dedup();
let count = sites.len();
CallItem {
call_sites: sites.into_iter().take(MAX_CALL_SITES).map(|r| place(sites_in.clone(), r)).collect(),
call_site_count: (count > MAX_CALL_SITES).then_some(count),
at: place(at, i.selection_range),
name: i.name,
kind: i.kind,
detail: i.detail,
}
};
let mut items: Vec<CallItem> = items.into_iter().map(&convert).collect();
items.sort_by(|a, b| {
(&a.at.file_path, a.at.start_line, a.at.start_column).cmp(&(
&b.at.file_path,
b.at.start_line,
b.at.start_column,
))
});
(root.map(convert), items)
}
/// Fills `lineText` of `places`, which are all in the file whose text is `text`.
fn fill_line_texts(places: &mut [&mut Place], text: &str) {
let lines: Vec<&str> = text.split('\n').collect();
for place in places {
let Some(line) = lines.get(place.start_line as usize - 1) else { continue };
let line = line.strip_suffix('\r').unwrap_or(line);
let start = place.start_column as usize - 1;
let end = if place.end_line == place.start_line { place.end_column as usize - 1 } else { start };
place.line_text = Some(super::search::snippet(line, start, end));
}
}
/// The innermost function, method or constructor of `outline` whose extent holds `pos`,
/// as the IDE's Call Hierarchy finds it.
fn enclosing_callable(outline: &[OutlineItem], pos: Pos) -> Option<&OutlineItem> {
let item = outline.iter().find(|i| i.range.start <= pos && pos <= i.range.end)?;
enclosing_callable(&item.children, pos).or_else(|| {
matches!(item.kind, SymbolKind::Function | SymbolKind::Method | SymbolKind::Constructor).then_some(item)
})
}
fn mcp_position(text: &str, line: i64, column: i64) -> IdeResult<Pos> {
if line < 1 || line > u32::MAX as i64 || column < 1 || column > u32::MAX as i64 {
return Err(IdeError::invalid("line and column must be positive 1-based positions"));
@@ -284,3 +531,156 @@ fn mcp_position(text: &str, line: i64, column: i64) -> IdeResult<Pos> {
}
Ok(Pos::new((line - 1) as u32, (column - 1) as u32))
}
#[cfg(test)]
mod tests {
use super::*;
fn range(line: u32, col: u32, end_line: u32, end_col: u32) -> Range {
Range::new(Pos::new(line, col), Pos::new(end_line, end_col))
}
fn item(name: &str, path: &str, line: u32, from_ranges: Vec<Range>) -> HierarchyItem {
HierarchyItem {
name: name.into(),
kind: SymbolKind::Function,
detail: Some(format!("fn {name}()")),
path: PathBuf::from(path).into(),
uri: None,
range: range(line, 0, line + 2, 1),
selection_range: range(line, 3, line, 3 + name.len() as u32),
from_ranges,
from_path: None,
}
}
fn shown(path: &Path) -> String {
path.strip_prefix("/p").unwrap_or(path).to_string_lossy().into_owned()
}
fn hierarchy(root: HierarchyItem, items: Vec<HierarchyItem>) -> CallHierarchy {
CallHierarchy { root: Some(root), items, incomplete: None }
}
#[test]
fn incoming_call_sites_are_in_the_callers_file_one_based() {
let h = hierarchy(
item("price", "/p/src/lib.rs", 10, Vec::new()),
vec![item("main", "/p/src/main.rs", 2, vec![range(4, 8, 4, 13)])],
);
let (root, items) = call_items(h, shown);
let root = serde_json::to_value(root.unwrap()).unwrap();
assert_eq!(
root,
json!({"name":"price","kind":"function","detail":"fn price()","filePath":"src/lib.rs",
"startLine":11,"startColumn":4,"endLine":11,"endColumn":9})
);
assert_eq!(
serde_json::to_value(&items).unwrap(),
json!([{"name":"main","kind":"function","detail":"fn main()","filePath":"src/main.rs",
"startLine":3,"startColumn":4,"endLine":3,"endColumn":8,
"callSites":[{"filePath":"src/main.rs","startLine":5,"startColumn":9,"endLine":5,"endColumn":14}]}])
);
}
#[test]
fn outgoing_call_sites_are_in_the_file_ide_lsp_names() {
let mut price = item("price", "/p/src/lib.rs", 10, vec![range(4, 8, 4, 13)]);
price.from_path = Some(PathBuf::from("/p/src/main.rs").into());
let (_, items) = call_items(hierarchy(item("main", "/p/src/main.rs", 2, Vec::new()), vec![price]), shown);
assert_eq!(items[0].at.file_path, "src/lib.rs");
assert_eq!(items[0].call_sites[0].file_path, "src/main.rs");
assert_eq!(items[0].call_sites[0].file.as_deref(), Some(Path::new("/p/src/main.rs")));
}
#[test]
fn library_items_show_their_uri() {
let mut library = item("len", "/virtual", 0, vec![range(4, 8, 4, 11)]);
library.uri = Some("jar:file:///lib.jar!/Str.class".into());
library.from_path = Some(PathBuf::from("/p/src/main.rs").into());
let mut called_from_library = item("parse", "/p/src/a.rs", 3, vec![range(1, 0, 1, 4)]);
called_from_library.from_path = Some(PathBuf::from("jdt://contents/lib.jar/Caller.class").into());
let h = hierarchy(item("main", "/p/src/main.rs", 2, Vec::new()), vec![library, called_from_library]);
let (_, items) = call_items(h, shown);
assert_eq!(items[0].at.file_path, "jar:file:///lib.jar!/Str.class");
assert_eq!(items[0].at.file, None, "no line text for a library item");
assert_eq!(items[0].call_sites[0].file_path, "src/main.rs");
assert_eq!(items[1].call_sites[0].file_path, "jdt://contents/lib.jar/Caller.class");
assert_eq!(items[1].call_sites[0].file, None);
}
#[test]
fn call_items_are_sorted_by_file_and_line() {
let h = hierarchy(
item("price", "/p/src/lib.rs", 10, Vec::new()),
vec![
item("c", "/p/src/main.rs", 9, Vec::new()),
item("b", "/p/src/main.rs", 2, Vec::new()),
item("a", "/p/src/a.rs", 5, Vec::new()),
],
);
let (_, items) = call_items(h, shown);
assert_eq!(items.iter().map(|i| i.name.as_str()).collect::<Vec<_>>(), ["a", "b", "c"]);
}
#[test]
fn call_sites_are_capped_with_their_count() {
let sites = (0..MAX_CALL_SITES as u32 + 5).map(|l| range(l, 0, l, 1)).collect();
let h = hierarchy(item("price", "/p/src/lib.rs", 10, Vec::new()), vec![item("main", "/p/a.rs", 0, sites)]);
let (_, items) = call_items(h, shown);
assert_eq!(items[0].call_sites.len(), MAX_CALL_SITES);
assert_eq!(items[0].call_site_count, Some(MAX_CALL_SITES + 5));
let one = hierarchy(
item("price", "/p/src/lib.rs", 10, Vec::new()),
vec![item("main", "/p/a.rs", 0, vec![range(1, 0, 1, 1)])],
);
assert_eq!(call_items(one, shown).1[0].call_site_count, None);
}
#[test]
fn call_sites_are_in_source_order_without_duplicates() {
let sites = vec![range(5, 0, 5, 1), range(1, 4, 1, 5), range(5, 0, 5, 1), range(1, 2, 1, 3)];
let h = hierarchy(item("price", "/p/src/lib.rs", 10, Vec::new()), vec![item("main", "/p/a.rs", 0, sites)]);
let (_, items) = call_items(h, shown);
let at: Vec<_> = items[0].call_sites.iter().map(|s| (s.start_line, s.start_column)).collect();
assert_eq!(at, [(2, 3), (2, 5), (6, 1)]);
assert_eq!(items[0].call_site_count, None);
}
#[test]
fn line_text_is_cut_from_the_line_of_each_place() {
let h = hierarchy(item("price", "/p/src/lib.rs", 3, vec![range(0, 4, 0, 9), range(1, 0, 3, 1)]), Vec::new());
let mut root = call_items(h, shown).0.unwrap();
let mut places: Vec<&mut Place> = std::iter::once(&mut root.at).chain(&mut root.call_sites).collect();
fill_line_texts(&mut places, " price();\r\nfn other() {\n\nfn price() {}");
assert_eq!(root.at.line_text.as_deref(), Some("fn price() {}"));
assert_eq!(root.call_sites[0].line_text.as_deref(), Some(" price();"));
assert_eq!(root.call_sites[1].line_text.as_deref(), Some("fn other() {"), "a range over lines");
}
#[test]
fn enclosing_callable_is_the_innermost_function() {
let outline = |name: &str, kind, range, children| OutlineItem {
name: name.into(),
detail: None,
kind,
range,
selection_range: Range::new(range.start, range.start),
children,
visibility: None,
};
let method = outline(
"total",
SymbolKind::Method,
range(2, 4, 8, 5),
vec![outline("add", SymbolKind::Function, range(3, 8, 5, 9), Vec::new())],
);
let items = vec![outline("Cart", SymbolKind::Struct, range(0, 0, 9, 1), vec![method])];
let name = |pos| enclosing_callable(&items, pos).map(|i| i.name.as_str());
assert_eq!(name(Pos::new(4, 0)), Some("add"));
assert_eq!(name(Pos::new(5, 9)), Some("add"), "the end is inside");
assert_eq!(name(Pos::new(7, 0)), Some("total"));
assert_eq!(name(Pos::new(0, 3)), None, "a struct is not callable");
assert_eq!(name(Pos::new(12, 0)), None);
}
}
+14
Переглянути файл
@@ -268,6 +268,19 @@ pub async fn agent_prompt(host: &Host, window: &str, task: String, prompt: Agent
host.project(window)?.agents.prompt(&task, prompt, now).await
}
/// Answers a non-blocking question, without cancelling the current turn.
#[command(trust = trusted)]
pub async fn agent_answer_question(
host: &Host,
window: &str,
task: String,
question: String,
answer: Option<String>,
) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.answer_question(&task, &question, answer).await
}
/// Drops a queued message and returns it (to edit it).
#[command(trust = always)]
pub fn agent_unqueue(host: &Host, window: &str, task: String, queued: String) -> IdeResult<AgentQueued> {
@@ -1015,6 +1028,7 @@ mod tests {
ide_command::domain!(
agent:
agent_accept_changes,
agent_answer_question,
agent_archive,
agent_base_text,
agent_cancel,
+5 -2
Переглянути файл
@@ -141,8 +141,11 @@ impl DependencyVersionSource for GoModules {
}
fn fetch(&self, package: &str, cancel: &CancellationToken) -> IdeResult<Vec<String>> {
let search =
self.env.get("PATH").map(std::ffi::OsString::from).unwrap_or_else(ide_core::tool_path::search_path);
let search = self
.env
.get("PATH")
.map(std::ffi::OsString::from)
.unwrap_or_else(|| ide_core::tool_path::search_path_in(&self.root));
let go = ide_core::tool_path::find_command("go", &search, &self.root)
.ok_or_else(|| IdeError::unavailable("Go SDK is unavailable"))?;
// A partially edited go.mod is often invalid. Query outside it while
+120 -6
Переглянути файл
@@ -93,12 +93,13 @@ fn detected_and_saved(
.linked_projects
.as_ref()
.map(|_| ide_build::gradle::load_linked(root, &settings.languages.java.gradle));
let mut all: Vec<RunConfig> =
ide_run::detect_with_profiles(root, &excluded_poms, settings.cmake.profiles.as_deref())
.into_iter()
.filter(|d| !suppressed.contains(&d.id) && !saved.iter().any(|u| u.id == d.id))
.filter(|d| linked_config(root, gradle.as_deref(), &excluded_poms, d))
.collect();
let mut detected = ide_run::detect_with_profiles(root, &excluded_poms, settings.cmake.profiles.as_deref());
detected.extend(ide_run::detect_builds(root, &linked_build_dirs(root, settings, gradle.as_deref(), &detected)));
let mut all: Vec<RunConfig> = detected
.into_iter()
.filter(|d| !suppressed.contains(&d.id) && !saved.iter().any(|u| u.id == d.id))
.filter(|d| linked_config(root, gradle.as_deref(), &excluded_poms, d))
.collect();
all.extend(saved.iter().cloned());
for config in all.iter_mut().filter(|c| !matches!(c.kind.as_str(), "gradle" | "maven")) {
ide_sdk::apply::apply_to_run_configs(std::slice::from_mut(config), root, settings);
@@ -106,6 +107,30 @@ fn detected_and_saved(
all
}
/// Folders of the Maven / Gradle builds linked explicitly (Add Maven Projects, linked Gradle
/// builds) that detection did not reach: deeper than its folder search and outside the builds
/// it found, which own their nested folders.
fn linked_build_dirs(
root: &Path,
settings: &ide_core::settings::Settings,
gradle: Option<&[ide_build::GradleModel]>,
detected: &[RunConfig],
) -> Vec<std::path::PathBuf> {
let found: Vec<_> = detected
.iter()
.filter(|c| matches!(c.kind.as_str(), "maven" | "gradle"))
.map(|c| ide_core::project_roots::resolve(root, c.cwd.as_deref().unwrap_or(Path::new(""))))
.collect();
let poms = settings.languages.java.maven.linked_projects.iter().filter_map(|pom| {
let pom = root.join(pom.trim());
pom.is_file().then(|| pom.parent().map(Path::to_path_buf)).flatten()
});
poms.chain(gradle.unwrap_or_default().iter().map(|build| root.join(&build.dir)))
.map(|dir| ide_core::project_roots::resolve(root, &dir))
.filter(|dir| !found.iter().any(|build| dir.starts_with(build)))
.collect()
}
fn linked_config(
root: &std::path::Path,
gradle: Option<&[ide_build::GradleModel]>,
@@ -605,6 +630,95 @@ mod ownership_tests {
let configs = detected_and_saved(root, &settings, &[], &[]);
assert!(configs.is_empty(), "{configs:?}");
}
/// #4066: a build linked explicitly is detected beyond the folder search depth.
#[test]
fn linked_builds_are_detected_at_any_depth() {
const BOOT_POM: &str = "<project><build><plugins><plugin><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>";
const APP: &str = "package com.example;\n@SpringBootApplication public class DemoApplication { public static void main(String[] a) {} }";
let deep = "site/service/03_src/demo-monitor";
let tool = "a/b/c/tool";
type Case =
(&'static str, Vec<(String, &'static str)>, Vec<&'static str>, Option<Vec<&'static str>>, Vec<String>);
let cases: Vec<Case> = vec![
(
"reporter: Maven module four levels deep, no root POM, linked",
vec![
(format!("{deep}/pom.xml"), BOOT_POM),
(format!("{deep}/src/main/java/com/example/DemoApplication.java"), APP),
],
vec!["site/service/03_src/demo-monitor/pom.xml"],
None,
vec![
format!("maven:package:{deep}"),
format!("maven:test:{deep}"),
format!("maven:spring-boot:run:{deep}"),
format!("application:{deep}:com.example.DemoApplication"),
],
),
(
"the same module, not linked: depth limit unchanged",
vec![(format!("{deep}/pom.xml"), BOOT_POM)],
vec![],
None,
vec![],
),
(
"Gradle build four levels deep, linked",
vec![(format!("{tool}/build.gradle.kts"), "plugins {\n application\n}")],
vec![],
Some(vec![tool]),
vec![format!("gradle:build:{tool}"), format!("gradle:test:{tool}"), format!("gradle:run:{tool}")],
),
(
"linked module inside the root reactor belongs to the reactor",
vec![("pom.xml".into(), "<project></project>"), (format!("{deep}/pom.xml"), BOOT_POM)],
vec!["site/service/03_src/demo-monitor/pom.xml"],
None,
vec!["maven:package".into(), "maven:test".into()],
),
(
"linked module within the search depth is not detected twice",
vec![("svc/pom.xml".into(), "<project></project>")],
vec!["svc/pom.xml"],
None,
vec!["maven:package:svc".into(), "maven:test:svc".into()],
),
];
for (name, files, maven, gradle, expected) in cases {
let temp = tempfile::tempdir().unwrap();
let root = temp.path();
for (path, text) in &files {
std::fs::create_dir_all(root.join(path).parent().unwrap()).unwrap();
std::fs::write(root.join(path), text).unwrap();
}
let mut settings = ide_core::settings::Settings::default();
settings.languages.java.maven.linked_projects = maven.into_iter().map(String::from).collect();
settings.languages.java.gradle.linked_projects = gradle.map(|d| d.into_iter().map(String::from).collect());
let configs = detected_and_saved(root, &settings, &[], &[]);
let mut ids: Vec<_> = configs.iter().map(|c| c.id.clone()).collect();
let mut expected = expected;
ids.sort();
expected.sort();
assert_eq!(ids, expected, "{name}");
for config in configs.iter().filter(|c| matches!(c.kind.as_str(), "maven" | "gradle")) {
let cwd = config.cwd.as_deref().map(|p| p.to_string_lossy().replace('\\', "/"));
assert!(config.id.ends_with(cwd.as_deref().unwrap_or("")), "{name}: {config:?}");
}
}
// A POM linked from outside the project folder (an extra content root).
let (temp, outside) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());
let external = dunce::canonicalize(outside.path()).unwrap().join("svc");
std::fs::create_dir_all(&external).unwrap();
std::fs::write(external.join("pom.xml"), BOOT_POM).unwrap();
let mut settings = ide_core::settings::Settings::default();
settings.languages.java.maven.linked_projects = vec![external.join("pom.xml").to_string_lossy().into_owned()];
let configs = detected_and_saved(temp.path(), &settings, &[], &[]);
let package =
configs.iter().find(|c| c.id == format!("maven:package:{}", external.to_string_lossy().replace('\\', "/")));
assert_eq!(package.and_then(|c| c.cwd.as_deref()), Some(external.as_path()), "{configs:?}");
}
}
ide_command::domain!(
+27
Переглянути файл
@@ -48,6 +48,10 @@ impl ReplaceHost for DocumentsHost<'_> {
/// update live and undo the whole file's replacements in one step. Unsaved
/// editor buffers are replaced in place and left unsaved; files that were not
/// open are opened transiently, saved and closed.
///
/// With `all_in_scope` (Replace All after the search hit its match limit) the
/// scope is searched again without the limit and every match in it is replaced,
/// as IDEA does: `targets` then only carry the `skip` positions of their files.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn replace_in_files(
@@ -58,12 +62,15 @@ pub async fn replace_in_files(
replacement: String,
preserve_case: bool,
targets: Vec<ReplaceTarget>,
all_in_scope: bool,
on_event: Channel<ReplaceEvent>,
) -> IdeResult<()> {
let project = host.project(window)?;
let cancel = host.begin_request(request);
let events = on_event.clone();
let syntax = host.syntax();
let summary = tokio::task::spawn_blocking(move || {
let targets = if all_in_scope { scope_targets(&project, &syntax, &query, targets, &cancel)? } else { targets };
let host = DocumentsHost(&project.documents);
ide_search::replace_files(&host, &query, &replacement, preserve_case, &targets, &cancel, &|e| {
let _ = events.send(e);
@@ -77,6 +84,26 @@ pub async fn replace_in_files(
Ok(())
}
/// Every file of `query`'s scope with a match (no match limit), sorted, each
/// keeping the `skip` positions `listed` gives it.
fn scope_targets(
project: &crate::project::Project,
syntax: &ide_language::Syntax,
query: &SearchQuery,
listed: Vec<ReplaceTarget>,
cancel: &ide_core::CancellationToken,
) -> IdeResult<Vec<ReplaceTarget>> {
let mut query = query.clone();
query.max_matches = u32::MAX;
query.exclude.extend(project.search_excludes());
let found = std::sync::Mutex::new(Vec::new());
super::search_project(project, syntax, &query, cancel, &|file| found.lock().unwrap().push(file.path))?;
let mut skip: std::collections::HashMap<_, _> = listed.into_iter().map(|t| (t.path, t.skip)).collect();
let mut paths = found.into_inner().unwrap();
paths.sort();
Ok(paths.into_iter().map(|path| ReplaceTarget { skip: skip.remove(&path).flatten(), path, only: None }).collect())
}
/// Before / after text of `path` for Replace › Preview (unsaved buffer included).
#[command(trust = trusted)]
pub async fn replace_preview(
+84
Переглянути файл
@@ -285,6 +285,36 @@ pub(super) enum Waiter {
Prompt(std::sync::mpsc::SyncSender<Option<Vec<String>>>),
Commit(std::sync::mpsc::SyncSender<CommitAnswer>),
Command(std::sync::mpsc::SyncSender<super::CommandAnswer>),
Clipboard(std::sync::mpsc::SyncSender<super::ClipboardAnswer>),
}
/// What a window read from its clipboard, as `ui.read-clipboard` returns it. Oversized text
/// or images fail here, before the base64 is decoded.
fn clipboard_content(answer: super::ClipboardAnswer) -> Result<ide_plugin::ClipboardContent, HostError> {
use base64::Engine;
let (text, png) = match answer {
super::ClipboardAnswer::Content { text, png } => (text, png),
super::ClipboardAnswer::Refused => return Err(HostError::Denied("clipboard.read (the user refused)".into())),
super::ClipboardAnswer::Failed { message } => return Err(HostError::Failed(message)),
};
let max = ide_plugin::MAX_CLIPBOARD_BYTES;
let too_large = || HostError::Failed(format!("the clipboard holds more than {} MiB", max >> 20));
// The longest base64 of `max` bytes.
if text.as_ref().is_some_and(|t| t.len() > max) || png.as_ref().is_some_and(|p| p.len() > max.div_ceil(3) * 4) {
return Err(too_large());
}
let image = match png.filter(|p| !p.is_empty()) {
Some(png) => Some(
base64::engine::general_purpose::STANDARD
.decode(png)
.map_err(|e| HostError::Failed(format!("the clipboard image is not valid base64: {e}")))?,
),
None => None,
};
if image.as_ref().is_some_and(|i| i.len() > max) {
return Err(too_large());
}
Ok(ide_plugin::ClipboardContent { text: text.filter(|t| !t.is_empty()), image })
}
/// A process a plugin started and has not released (API 1.3 `process.start`).
@@ -953,6 +983,17 @@ impl Shared {
tx.try_send(answer).is_ok()
}
/// The window a [`PluginEvent::ClipboardRequested`] went to answered it.
pub fn answer_clipboard(&self, client: &str, id: u64, answer: super::ClipboardAnswer) -> bool {
let mut prompts = self.prompts.lock();
if !matches!(prompts.get(&id), Some(PromptEntry { client: window, answer: Waiter::Clipboard(_), .. }) if window == client)
{
return false;
}
let Some(PromptEntry { answer: Waiter::Clipboard(tx), .. }) = prompts.remove(&id) else { return false };
tx.try_send(answer).is_ok()
}
pub fn answer_commit(&self, id: u64, answer: CommitAnswer) -> bool {
let mut prompts = self.prompts.lock();
if !matches!(prompts.get(&id), Some(PromptEntry { answer: Waiter::Commit(_), .. })) {
@@ -1888,6 +1929,49 @@ impl HostApi for PluginApi {
Ok(())
}
fn read_clipboard(
&self,
client: &str,
cancel: &CancellationToken,
) -> Result<ide_plugin::ClipboardContent, HostError> {
let id = self.shared.next_prompt.fetch_add(1, Ordering::Relaxed);
let (answer, answers) = std::sync::mpsc::sync_channel(1);
{
let closed = self.shared.closed_clients.lock();
let blocked = self.shared.prompts_blocked.lock();
if closed.contains(client) || blocked.contains(self.id()) {
return Err(HostError::Cancelled);
}
self.shared.prompts.lock().insert(
id,
PromptEntry {
plugin: self.id().to_owned(),
client: client.to_owned(),
answer: Waiter::Clipboard(answer),
},
);
}
let request_id = id.to_string();
self.shared.sink.emit(
Some(client),
PluginEvent::ClipboardRequested { plugin_id: self.id().to_owned(), request_id: request_id.clone() },
);
// A remote window asks the user first, so there is no deadline: the call's own
// cancellation, the plugin stopping or the window closing ends the wait.
let answer = loop {
match answers.recv_timeout(Duration::from_millis(100)) {
Ok(answer) => break answer,
Err(std::sync::mpsc::RecvTimeoutError::Timeout) if !cancel.is_cancelled() => {}
Err(_) => {
self.shared.prompts.lock().remove(&id);
self.shared.sink.emit(Some(client), PluginEvent::PromptClosed { prompt_id: request_id });
return Err(HostError::Cancelled);
}
}
};
clipboard_content(answer)
}
fn open_url(&self, client: Option<&str>, url: String) -> Result<(), HostError> {
let client = from_window(client, "open a URL")?;
self.shared.sink.emit(Some(client), PluginEvent::OpenUrl { plugin_id: self.id().to_owned(), url });
+15 -2
Переглянути файл
@@ -1,8 +1,8 @@
//! Plugin window commands shared by local IPC and remote RPC.
use super::{
CommandAnswer, CommitAnswer, DecorationSet, EventKind, PluginContextKey, PluginEditor, PluginHost, PluginInfo,
PluginStatusItem, WorkbenchEvent,
ClipboardAnswer, CommandAnswer, CommitAnswer, DecorationSet, EventKind, PluginContextKey, PluginEditor, PluginHost,
PluginInfo, PluginStatusItem, WorkbenchEvent,
};
use crate::Host;
use ide_command::command;
@@ -127,6 +127,18 @@ pub fn plugin_answer_command(
Ok(plugins.answer_command(window, &request_id, answer))
}
/// This window's clipboard for a plugin's `clipboardRequested`; false when the call no
/// longer waits or asked another window.
#[command(trust = trusted)]
pub fn plugin_answer_clipboard(
plugins: &Arc<PluginHost>,
window: &str,
request_id: String,
answer: ClipboardAnswer,
) -> IdeResult<bool> {
Ok(plugins.answer_clipboard(window, &request_id, answer))
}
/// The project root a `scope` setting applies to (`None`: global).
fn scope_root(host: &Host, window: &str, scope: SettingsScope) -> IdeResult<Option<PathBuf>> {
Ok(match scope {
@@ -278,6 +290,7 @@ pub async fn plugin_debug_attach_target(
ide_command::domain!(
plugins_commands:
plugin_answer_clipboard,
plugin_answer_command,
plugin_answer_commit,
plugin_answer_prompt,
+41 -28
Переглянути файл
@@ -5,7 +5,7 @@ use ide_extension::Capability;
use ide_plugin::{EventKind, HostError, WorkbenchEvent};
use std::{
collections::{BTreeSet, HashMap},
path::Path,
path::{Path, PathBuf},
};
#[derive(Clone, Default)]
@@ -136,32 +136,14 @@ impl PluginHost {
if !path.is_absolute() {
return None;
}
let workspace = workspace.as_ref()?;
let real = ide_plugin::resolve_real(path);
// The file's own project, not the invoking window's: annotations follow
// the file, so a plugin hears about a file another window has open.
let root = match client {
Some(client) => workspace
.project_of(client)
.filter(|r| real.starts_with(ide_plugin::resolve_real(r)))
.or_else(|| {
workspace
.projects()
.into_iter()
.filter(|r| real.starts_with(ide_plugin::resolve_real(r)))
.max_by_key(|r| r.components().count())
}),
None => workspace
.projects()
.into_iter()
.filter(|r| real.starts_with(ide_plugin::resolve_real(r)))
.max_by_key(|r| r.components().count()),
}?;
let root = file_project(workspace.as_deref()?, client, path)?;
if plugin.dev_root.as_deref().is_some_and(|r| r != root) {
return None;
}
if let WorkbenchEvent::DocumentChanged(change) = event {
if let WorkbenchEvent::DocumentChanged(_) = event {
// Typed text: only for plugins that may read editors, and only for paths they named.
// The path stays absolute until delivery (`relativize_documents`): the batch is
// filtered again then, against the grants and subscriptions of that moment.
let filter = filters.and_then(|filters| filters.get(event.kind().name()))?;
let granted = &plugin.meta.lock().granted;
if !granted.contains(&Capability::ProjectRead)
@@ -170,11 +152,7 @@ impl PluginHost {
{
return None;
}
let real = ide_plugin::resolve_real(path);
let relative = real.strip_prefix(ide_plugin::resolve_real(&root)).ok()?;
let mut change = change.clone();
change.path = relative.to_string_lossy().replace('\\', "/");
return Some(WorkbenchEvent::DocumentChanged(change));
return Some(event.clone());
}
filters
.and_then(|filters| filters.get(event.kind().name()))
@@ -183,6 +161,41 @@ impl PluginHost {
})
.collect()
}
/// What a plugin receives for `document-changed`: the path relative to the file's own project.
pub(super) fn relativize_documents(
shared: &super::api::Shared,
client: Option<&str>,
events: Vec<WorkbenchEvent>,
) -> Vec<WorkbenchEvent> {
let workspace = shared.workspace();
events
.into_iter()
.filter_map(|event| {
let WorkbenchEvent::DocumentChanged(mut change) = event else { return Some(event) };
let path = Path::new(&change.path);
let root = file_project(workspace.as_deref()?, client, path)?;
let relative = ide_plugin::resolve_real(path)
.strip_prefix(ide_plugin::resolve_real(&root))
.ok()?
.to_string_lossy()
.replace('\\', "/");
change.path = relative;
Some(WorkbenchEvent::DocumentChanged(change))
})
.collect()
}
}
/// The open project an absolute `path` belongs to: the invoking window's when the file is in
/// it, else the innermost open project containing it. Annotations follow the file, so a
/// plugin hears about a file another window has open.
fn file_project(workspace: &dyn super::api::PluginWorkspace, client: Option<&str>, path: &Path) -> Option<PathBuf> {
let real = ide_plugin::resolve_real(path);
let contains = |r: &PathBuf| real.starts_with(ide_plugin::resolve_real(r));
client
.and_then(|client| workspace.project_of(client).filter(contains))
.or_else(|| workspace.projects().into_iter().filter(contains).max_by_key(|r| r.components().count()))
}
#[cfg(test)]
+7 -3
Переглянути файл
@@ -33,10 +33,10 @@ struct Decl {
}
#[derive(Clone, Debug)]
struct Agent {
pub(super) struct Agent {
/// The jar, resolved inside the package.
jar: PathBuf,
args: Option<String>,
pub(super) jar: PathBuf,
pub(super) args: Option<String>,
}
/// Agents of enabled plugins.
@@ -47,6 +47,10 @@ pub struct JavaAgents {
}
impl JavaAgents {
pub(super) fn for_plugin(&self, plugin: &str) -> Option<Agent> {
self.items.read().iter().find(|(_, id, _)| id == plugin).map(|(_, _, agent)| agent.clone())
}
fn add(self: &Arc<Self>, plugin: String, agent: Agent) -> Disposable {
let seq = self.seq.fetch_add(1, Ordering::Relaxed);
self.items.write().push((seq, plugin, agent));
+27
Переглянути файл
@@ -1806,6 +1806,12 @@ impl PluginHost {
request.parse().is_ok_and(|id| self.shared.answer_command(client, id, answer))
}
/// A window answered a plugin's `ClipboardRequested`; false when the call no longer
/// waits or asked another window.
pub fn answer_clipboard(&self, client: &str, request_id: &str, answer: ClipboardAnswer) -> bool {
request_id.parse().is_ok_and(|id| self.shared.answer_clipboard(client, id, answer))
}
pub fn answer_commit(&self, request_id: &str, answer: CommitAnswer) -> bool {
request_id.parse().is_ok_and(|id| self.shared.answer_commit(id, answer))
}
@@ -2214,6 +2220,7 @@ impl PluginHost {
if events.is_empty() {
return Ok(());
}
let events = Self::relativize_documents(&shared, invocation.client.as_deref(), events);
rt.handle_events(events, invocation)
},
move |result| {
@@ -3087,6 +3094,26 @@ impl PluginHost {
homepage: m.homepage.clone(),
change_notes: m.change_notes.clone(),
icon: p.icon.clone(),
java_agent: self.java_agents.for_plugin(&m.id).map(|agent| {
let pin = self
.ledger
.lock()
.get(&p.subject())
.filter(|grant| grant.has(&Capability::JavaAgent))
.and_then(|grant| grant.binaries.get(&Capability::JavaAgent.to_string()).cloned());
let approved = pin.as_ref().is_some_and(|pin| {
pin.path == agent.jar && ledger::file_hash(&pin.path).is_ok_and(|hash| hash == pin.hash)
});
PluginJavaAgent {
file_name: agent
.jar
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_else(|| agent.jar.display().to_string()),
args: agent.args,
approved,
}
}),
source: p.source,
path: p.dir().to_path_buf().into(),
enabled: !self.state.lock().disabled.contains(&m.id),
+1
Переглянути файл
@@ -169,6 +169,7 @@ pub fn forwarded(event: &PluginEvent) -> bool {
| PluginEvent::PromptWaiting { .. }
| PluginEvent::RevealView { .. }
| PluginEvent::CommitRequested { .. }
| PluginEvent::ClipboardRequested { .. }
| PluginEvent::EndpointsChanged { .. }
)
}
+30
Переглянути файл
@@ -55,6 +55,18 @@ impl PluginStatus {
}
}
/// The Java agent a plugin contributes, for Settings › Plugins.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct PluginJavaAgent {
/// The jar's file name.
pub file_name: String,
/// The optional argument passed after `=`.
pub args: Option<String>,
/// The jar still has the hash recorded when `java.agent` was granted.
pub approved: bool,
}
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct PluginInfo {
@@ -66,6 +78,8 @@ pub struct PluginInfo {
pub homepage: Option<String>,
pub change_notes: Option<String>,
pub icon: Option<PluginIcon>,
/// The Java agent this plugin declares, and whether it is still approved.
pub java_agent: Option<PluginJavaAgent>,
pub source: PluginSource,
/// Package directory.
pub path: ide_core::IpcPath,
@@ -338,6 +352,10 @@ pub enum PluginEvent {
/// `plugin_answer_commit(request_id, …)`. Closed like a prompt (`PromptClosed`).
#[serde(rename_all = "camelCase")]
CommitRequested { plugin_id: String, request_id: String, request: CommitRequest },
/// A command the user ran reads the clipboard (`ui.read-clipboard`): answer with
/// `plugin_answer_clipboard(request_id, …)`. Closed like a prompt (`PromptClosed`).
#[serde(rename_all = "camelCase")]
ClipboardRequested { plugin_id: String, request_id: String },
}
/// What a plugin asks of a window's Commit view.
@@ -475,6 +493,18 @@ pub struct PluginCommitCheckResult {
pub error: Option<String>,
}
/// A window's answer to `ClipboardRequested`: its machine's clipboard.
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase")]
pub enum ClipboardAnswer {
/// `None` for a kind the clipboard doesn't hold; `png` is base64.
Content { text: Option<String>, png: Option<String> },
/// The user refused (a remote window asks first).
Refused,
/// The window could not read the clipboard.
Failed { message: String },
}
/// The invoking window's response to a command request.
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(tag = "kind", content = "value", rename_all = "camelCase")]
+83
Переглянути файл
@@ -108,6 +108,9 @@ impl Host {
let trusted = Arc::new(AtomicBool::new(self.trust.window_trusted(&root)?));
let post_start =
trusted.load(Ordering::Acquire).then(|| self.environment.project_opened(&root, &sink)).flatten();
if trusted.load(Ordering::Acquire) {
self.environment.direnv_opened(&root, &sink);
}
let settings = SettingsStore::load(&self.config_dir, Some(&root));
let detected_roots = Arc::new(RwLock::new(ide_workspace::roots::detect(&root)));
let excludes = exclude_globs(&root, &settings.effective(), &detected_roots.read());
@@ -180,7 +183,14 @@ impl Host {
ide_sdk::apply::server_launch_overrides(cfg, &effective);
ide_sdk::apply::configure_server(cfg, root, server_root, &effective);
ide_sdk::apply::configure_vue_module_resolution(cfg, &data_dir);
let container_python = effective.languages.python.run_target().is_some();
crate::ops::sdk::container_python::configure_server(cfg, &data_dir, root, &effective);
// Attached dependency projects are source, so basedpyright/Pyright should
// resolve imports into them. A container target already supplies its own
// `extraPaths` (the site-packages snapshot); don't mix local sources into it.
if !container_python {
ide_sdk::apply::configure_python_extra_paths(cfg, &python_dependency_roots(&effective, root));
}
if cfg.name == "jdtls" {
// A workspace member keeps its build model under its own key (Build Project).
let cache = match &member {
@@ -387,6 +397,14 @@ impl Host {
if composer_changed(&root, changed.iter().chain(&batch.removed)) {
lsp.reconfigure_soon();
}
// Not while loading: a first `use flake` may write `flake.lock` itself.
if trusted.load(Ordering::Acquire)
&& !ide_core::project_env::is_loading(&root)
&& let Some(file) = crate::direnv::reload_offer(&root, changed.iter().chain(&batch.removed))
{
let status = ide_core::event::DirenvStatus::Changed { file };
sink.emit(IdeEvent::Direnv { root: root.clone().into(), status });
}
// Atomic saves by external tools surface as `created`.
documents.on_disk_changed(&[&changed[..], &ignored].concat());
if let Some(plugins) = crate::plugins::editor_plugin_host() {
@@ -1483,6 +1501,30 @@ fn member_dependencies_for<'a>(map: &'a BTreeMap<String, Vec<String>>, own_key:
map.iter().find(|(key, _)| ide_core::ipc_path::to_ipc(&PathBuf::from(key)) == own_key).map(|(_, deps)| deps)
}
/// Dependency roots of `root`, for a Python language server's `analysis.extraPaths`.
/// In a workspace a member depends only on the roots picked for it in Project
/// Structure › Dependencies; outside one, the project-level `dependencies` list applies.
fn python_dependency_roots(settings: &ide_core::settings::Settings, root: &Path) -> Vec<PathBuf> {
let own_key = ide_core::ipc_path::to_ipc(root);
let configured = if ide_workspace::workspace::Workspace::load(root).ok().flatten().is_some() {
member_dependencies_for(&settings.project_structure.member_dependencies, &own_key).cloned().unwrap_or_default()
} else {
settings.project_structure.dependencies.clone()
};
configured
.into_iter()
.map(|p| PathBuf::from(p.trim()))
.filter(|p| p.is_absolute() && p.is_dir())
// A `src` layout keeps its packages one level down; basedpyright searches a
// project's own `src` by itself, but not an extra path's.
.flat_map(|p| {
let src = p.join("src");
let src = src.is_dir().then_some(src);
std::iter::once(p).chain(src)
})
.collect()
}
fn extra_content_roots(
settings: &ide_core::settings::Settings,
root: &Path,
@@ -2217,6 +2259,47 @@ mod content_roots_tests {
assert_eq!(roots, vec![shared, dep]);
}
#[test]
fn python_dependency_roots_use_project_dependencies_outside_a_workspace() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("app");
let dep = tmp.path().join("lib");
let missing = tmp.path().join("gone");
std::fs::create_dir_all(&root).unwrap();
std::fs::create_dir_all(&dep).unwrap();
let src_layout = tmp.path().join("pkg");
std::fs::create_dir_all(src_layout.join("src/pkg")).unwrap();
let mut settings = ide_core::settings::Settings::default();
settings.project_structure.dependencies = vec![
dep.to_string_lossy().into_owned(),
missing.to_string_lossy().into_owned(),
"relative".into(),
src_layout.to_string_lossy().into_owned(),
];
assert_eq!(
super::python_dependency_roots(&settings, &root),
vec![dep, src_layout.clone(), src_layout.join("src")]
);
}
#[test]
fn python_dependency_roots_use_the_members_own_picks_inside_a_workspace() {
let tmp = tempfile::tempdir().unwrap();
let ws = dunce::canonicalize(tmp.path()).unwrap();
let (app, lib, other) = (ws.join("app"), ws.join("lib"), ws.join("other"));
for dir in [&app, &lib, &other] {
std::fs::create_dir_all(dir).unwrap();
}
ide_workspace::workspace::Workspace::attach(&app, "ws", vec![app.clone(), lib.clone(), other.clone()]).unwrap();
let mut settings = ide_core::settings::Settings::default();
let key = |p: &std::path::Path| ide_core::ipc_path::to_ipc(p);
settings.project_structure.member_dependencies.insert(key(&app), vec![key(&lib)]);
settings.project_structure.member_dependencies.insert(key(&other), vec![key(&app)]);
// Project-level dependencies are ignored: inside a workspace, members pick their own.
settings.project_structure.dependencies = vec![key(&other)];
assert_eq!(super::python_dependency_roots(&settings, &app), vec![lib]);
}
#[test]
fn projects_attached_inside_the_root_get_their_own_language_server_root() {
let tmp = tempfile::tempdir().unwrap();
+1
Переглянути файл
@@ -184,6 +184,7 @@ pub fn client_accepts(event: &IdeEvent) -> bool {
| IdeEvent::UpdateAvailable { .. } => false,
IdeEvent::DbSourcesChanged
| IdeEvent::ProjectTrustChanged { .. }
| IdeEvent::Direnv { .. }
| IdeEvent::FsChanged { .. }
| IdeEvent::ExcludedDirsChanged { .. }
| IdeEvent::DocPatched { .. }
+2
Переглянути файл
@@ -275,10 +275,12 @@ impl crate::Host {
if let Some(cmd) = self.environment.project_opened(&project.root, &project.sink) {
self.environment.spawn_post_start(cmd, project.root.clone(), project.sink.clone());
}
self.environment.direnv_opened(&project.root, &project.sink);
project.lsp.set_execution_allowed(true);
project.lsp.prewarm_java_configuration();
} else {
self.environment.project_closed();
self.environment.direnv_closed(&project.root);
project.agents.shutdown();
self.processes.kill_project(&project.root);
project.notebooks.restrict().await;
+130
Переглянути файл
@@ -0,0 +1,130 @@
//! A project's direnv environment through the host, with a stand-in `direnv` on `PATH`: it
//! runs in trusted projects only, reaches the children started in the project, loads again
//! on Reload Environment and goes with trust or the project.
//! One test in its own binary: it changes this process's `PATH`.
#![cfg(unix)]
use ide_core::event::DirenvStatus;
use ide_core::{EventSink, IdeEvent, SharedSink};
use ide_host::{Host, HostConfig};
use parking_lot::Mutex;
use std::os::unix::fs::PermissionsExt;
use std::path::Path;
use std::process::Command;
use std::sync::Arc;
use std::time::{Duration, Instant};
#[derive(Default)]
struct Events(Mutex<Vec<IdeEvent>>);
impl EventSink for Events {
fn emit(&self, e: IdeEvent) {
self.0.lock().push(e);
}
}
/// What a child started in `dir` now sees for `name`.
fn child_var(dir: &Path, name: &str) -> String {
let out = ide_core::process::prepare(Command::new("/bin/sh").current_dir(dir))
.args(["-c", &format!("printf %s \"${name}\"")])
.output()
.unwrap();
String::from_utf8(out.stdout).unwrap()
}
fn wait_for(what: &str, mut done: impl FnMut() -> bool) {
let deadline = Instant::now() + Duration::from_secs(20);
while !done() {
assert!(Instant::now() < deadline, "timed out waiting for {what}");
std::thread::sleep(Duration::from_millis(20));
}
}
#[test]
fn direnv_runs_in_trusted_projects_and_reaches_their_children() {
let tmp = tempfile::tempdir().unwrap();
let tmp = dunce::canonicalize(tmp.path()).unwrap();
let bin = tmp.join("bin");
std::fs::create_dir_all(&bin).unwrap();
// Logs each run to `runs` and prints `out.json`, or blocks like direnv on `.envrc` not allowed.
let direnv = bin.join("direnv");
std::fs::write(
&direnv,
"#!/bin/sh\necho run >> runs\n[ -f blocked ] && { echo \"direnv: error $PWD/.envrc is blocked. Run \\`direnv allow\\` to approve its content\" >&2; exit 1; }\ncat out.json\n",
)
.unwrap();
std::fs::set_permissions(&direnv, std::fs::Permissions::from_mode(0o755)).unwrap();
let path =
std::env::join_paths(std::iter::once(bin).chain(std::env::split_paths(&std::env::var_os("PATH").unwrap())))
.unwrap();
// SAFETY: no other thread runs yet.
unsafe {
std::env::set_var("PATH", path);
// Reload Environment must not read this machine's login shell.
std::env::set_var("OPENIDEA_SKIP_SHELL_ENV", "1");
}
let project = tmp.join("flake-project");
std::fs::create_dir_all(project.join("src")).unwrap();
std::fs::write(project.join(".envrc"), "use flake\n").unwrap();
std::fs::write(project.join("out.json"), r#"{"OPENIDEA_DEVSHELL":"one"}"#).unwrap();
let runs = || std::fs::read_to_string(project.join("runs")).unwrap_or_default().lines().count();
let runtime = tokio::runtime::Builder::new_multi_thread().worker_threads(2).enable_all().build().unwrap();
let events = Arc::new(Events::default());
let sink_events = events.clone();
let base = tmp.join("host");
let host = Arc::new(Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("data"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(move |_| sink_events.clone() as SharedSink),
owner: |w| w,
runtime: runtime.handle().clone(),
// The desktop: several projects in one process.
project_environment: false,
}));
// Restricted Mode: `.envrc` is project code and doesn't run.
host.trust.decide(&project, false, false).unwrap();
runtime.block_on(ide_host::ops::project::open(&host, "main", &project)).unwrap();
std::thread::sleep(Duration::from_millis(300));
assert_eq!(runs(), 0);
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "");
// Trusted: it loads, for children started in the project only.
runtime.block_on(host.set_project_trust(&project, true, false)).unwrap();
wait_for("the direnv environment", || child_var(&project.join("src"), "OPENIDEA_DEVSHELL") == "one");
assert_eq!(runs(), 1);
assert_eq!(child_var(&tmp, "OPENIDEA_DEVSHELL"), "", "outside the project");
// Reload Environment loads it again.
std::fs::write(project.join("out.json"), r#"{"OPENIDEA_DEVSHELL":"two"}"#).unwrap();
let reloaded = runtime.block_on(ide_host::ops::env::env_reload(&host, "main")).unwrap();
assert!(reloaded.changed.iter().any(|c| c == "OPENIDEA_DEVSHELL"), "{:?}", reloaded.changed);
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "two");
// Blocked after an edit: said so, never allowed by the IDE, and the environment goes.
std::fs::write(project.join("blocked"), "").unwrap();
runtime.block_on(ide_host::ops::env::env_reload(&host, "main")).unwrap();
assert!(
events.0.lock().iter().any(|e| matches!(e, IdeEvent::Direnv { status: DirenvStatus::Blocked, .. })),
"a blocked notice"
);
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "");
std::fs::remove_file(project.join("blocked")).unwrap();
runtime.block_on(ide_host::ops::env::env_reload(&host, "main")).unwrap();
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "two");
// Revoking trust drops it; so does closing the project.
runtime.block_on(host.set_project_trust(&project, false, false)).unwrap();
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "");
runtime.block_on(host.set_project_trust(&project, true, false)).unwrap();
wait_for("the reloaded environment", || child_var(&project, "OPENIDEA_DEVSHELL") == "two");
host.close_project("main");
assert_eq!(child_var(&project, "OPENIDEA_DEVSHELL"), "");
runtime.block_on(host.shutdown());
}
+243
Переглянути файл
@@ -662,6 +662,34 @@ async fn rust_references_and_rename_through_mcp() {
assert!(std::time::Instant::now() < deadline, "language server did not find format_price references");
tokio::time::sleep(std::time::Duration::from_millis(500)).await;
}
// Its callers, the callees of one of them, and the hierarchy at a call.
let callers = h.json("get_call_hierarchy", args.clone()).await;
assert_eq!(callers["root"]["name"], "format_price", "{callers}");
let main = callers["items"].as_array().unwrap().iter().find(|i| i["name"] == "main").expect("main calls it");
assert_eq!(main["filePath"], "src/main.rs");
let call = main["callSites"]
.as_array()
.unwrap()
.iter()
.find(|s| s["lineText"].as_str().unwrap().contains("format_price("))
.expect("the call in main");
assert_eq!(call["filePath"], "src/main.rs");
let callees = h
.json("get_call_hierarchy", json!({"filePath":"src/main.rs", "line":main["startLine"], "column":main["startColumn"], "direction":"outgoing"}))
.await;
// rust-analyzer leaves out the calls inside macro arguments, such as `format_price` in `println!`.
let parse = callees["items"].as_array().unwrap().iter().find(|i| i["name"] == "parse").expect("main calls parse");
assert_eq!(
(&parse["filePath"], &parse["callSites"][0]["filePath"]),
(&json!("src/parser.rs"), &json!("src/main.rs"))
);
let at_call = h
.json("get_call_hierarchy", json!({"filePath":"src/main.rs", "line":call["startLine"], "column":call["startColumn"], "direction":"outgoing"}))
.await;
assert_eq!(
(&at_call["root"]["name"], &at_call["root"]["filePath"]),
(&json!("format_price"), &json!("src/lib.rs"))
);
let result = h.json("rename_refactoring", json!({"pathInProject":"src/lib.rs", "symbolName":"format_price", "newName":"format_amount", "line":line + 1, "column":column})).await;
assert_eq!(result["applied"], true, "{result}");
assert!(project.documents.text_snapshot(doc.id).unwrap().text.contains("format_amount"));
@@ -979,3 +1007,218 @@ async fn http_list_and_run_require_confirmation() {
assert!(result.get("headers").is_none(), "{result}");
assert!(result.get("request").is_none(), "{result}");
}
#[tokio::test(flavor = "multi_thread")]
async fn call_hierarchy_is_listed_for_untrusted_projects() {
let h = Harness::new();
let tools = Registry::new(h.host.clone()).tools(&h.root).unwrap();
assert!(tools.iter().any(|t| t.name == "get_call_hierarchy"));
}
#[tokio::test(flavor = "multi_thread")]
async fn call_hierarchy_without_a_language_server_says_it_is_unsupported() {
let h = Harness::new();
let error = h.error("get_call_hierarchy", json!({"filePath":"src/a.txt","line":1,"column":1})).await;
assert!(error.contains("call hierarchy"), "{error}");
}
#[tokio::test(flavor = "multi_thread")]
async fn call_hierarchy_rejects_an_unknown_direction() {
let h = Harness::new();
let args = json!({"filePath":"src/a.txt","line":1,"column":1,"direction":"up"});
assert_eq!(h.error("get_call_hierarchy", args).await, "direction must be incoming or outgoing");
}
/// `src/lib.rs`: `price` calls `double`; `src/main.rs`: `main` calls `price` and `show`;
/// `other/c.rs`: `helper` calls `price`; a library class calls it too.
const LIB_RS: &str = "pub fn price(cents: u64) -> u64 {\n double(cents)\n}\nfn double(v: u64) -> u64 { v * 2 }\n";
const MAIN_RS: &str = "fn main() {\n let a = price(1);\n show(a);\n}\nfn show(v: u64) {}\n";
const C_RS: &str = "fn helper() {\n price(2);\n}\n";
const LIBRARY_URI: &str = "jar:file:///lib.jar!/Caller.class";
/// A language server for `rust` that knows the call hierarchy of the files above.
struct CallServer {
root: PathBuf,
}
impl CallServer {
fn uri(&self, path: &str) -> String {
ide_lsp::path_to_uri_string(&self.root.join(path))
}
fn item(&self, name: &str) -> Value {
let r = |l, c, l2, c2| json!({"start":{"line":l,"character":c},"end":{"line":l2,"character":c2}});
let (uri, range, selection) = match name {
"price" => (self.uri("src/lib.rs"), r(0, 0, 2, 1), r(0, 7, 0, 12)),
"double" => (self.uri("src/lib.rs"), r(3, 0, 3, 34), r(3, 3, 3, 9)),
"main" => (self.uri("src/main.rs"), r(0, 0, 3, 1), r(0, 3, 0, 7)),
"show" => (self.uri("src/main.rs"), r(4, 0, 4, 18), r(4, 3, 4, 7)),
"helper" => (self.uri("other/c.rs"), r(0, 0, 2, 1), r(0, 3, 0, 9)),
_ => (LIBRARY_URI.to_owned(), r(0, 0, 9, 1), r(2, 4, 2, 10)),
};
json!({"name":name,"kind":12,"uri":uri,"range":range,"selectionRange":selection})
}
fn call(&self, name: &str, key: &str, sites: &[(u32, u32, u32)]) -> Value {
let sites: Vec<Value> = sites
.iter()
.map(|(l, c, c2)| json!({"start":{"line":l,"character":c},"end":{"line":l,"character":c2}}))
.collect();
json!({key: self.item(name), "fromRanges": sites})
}
/// The item named at `p`: on a declaration's name or on a call.
fn prepare(&self, p: &Value) -> Value {
let uri = p["textDocument"]["uri"].as_str().unwrap();
let (line, col) = (p["position"]["line"].as_u64().unwrap(), p["position"]["character"].as_u64().unwrap());
let on =
|path: &str, l: u64, from: u64, to: u64| uri == self.uri(path) && line == l && (from..=to).contains(&col);
let name = if on("src/lib.rs", 0, 7, 12) || on("src/main.rs", 1, 12, 17) {
"price"
} else if on("src/main.rs", 0, 3, 7) {
"main"
} else {
return Value::Null;
};
json!([self.item(name)])
}
}
impl ide_jsonrpc::Handler for CallServer {
fn on_notification(&self, _: &str, _: Value) {}
fn on_request(&self, method: &str, p: Value) -> Result<Value, (i64, String)> {
let item = p["item"]["name"].as_str().unwrap_or_default();
Ok(match method {
"initialize" => json!({"capabilities": {
"textDocumentSync": {"openClose": true, "change": 1},
"callHierarchyProvider": true,
"documentSymbolProvider": true,
}}),
"textDocument/prepareCallHierarchy" => self.prepare(&p),
"callHierarchy/incomingCalls" if item == "price" => json!([
self.call("main", "from", &[(1, 12, 17)]),
self.call("helper", "from", &[(1, 4, 9)]),
self.call("Caller", "from", &[(2, 8, 13)]),
]),
"callHierarchy/outgoingCalls" if item == "price" => json!([self.call("double", "to", &[(1, 4, 10)])]),
"callHierarchy/outgoingCalls" if item == "main" => {
json!([self.call("show", "to", &[(2, 4, 8)]), self.call("price", "to", &[(1, 12, 17)])])
}
"textDocument/documentSymbol" if p["textDocument"]["uri"] == self.uri("src/main.rs") => {
let symbol = |name| {
let item = self.item(name);
json!({"name":name,"kind":12,"range":item["range"],"selectionRange":item["selectionRange"]})
};
json!([symbol("main"), symbol("show")])
}
"callHierarchy/incomingCalls" | "callHierarchy/outgoingCalls" | "textDocument/documentSymbol" => json!([]),
_ => Value::Null,
})
}
}
/// The harness with the files above and [`CallServer`] serving them.
async fn call_hierarchy_harness() -> (Harness, tokio::task::JoinHandle<()>) {
let h = Harness::new();
h.trust().await;
for (path, text) in [("src/lib.rs", LIB_RS), ("src/main.rs", MAIN_RS), ("other/c.rs", C_RS)] {
std::fs::create_dir_all(h.root.join(path).parent().unwrap()).unwrap();
std::fs::write(h.root.join(path), text).unwrap();
}
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
let port = listener.local_addr().unwrap().port();
let server = Arc::new(CallServer { root: h.root.clone() });
let accept = tokio::spawn(async move {
let mut peers = Vec::new();
while let Ok((stream, _)) = listener.accept().await {
let (r, w) = stream.into_split();
peers.push(ide_jsonrpc::Peer::connect(r, w, server.clone()));
}
});
let cfg: ide_language::LanguageServerConfig =
toml::from_str(&format!("name='calls'\ncommand='no-process-required'\nconnect='127.0.0.1:{port}'")).unwrap();
h.host.project("main").unwrap().lsp.set_servers_hook(Box::new(move |language, _| {
if language.as_str() == "rust" { vec![cfg.clone()] } else { Vec::new() }
}));
(h, accept)
}
fn names(result: &Value) -> Vec<&str> {
result["items"].as_array().unwrap().iter().map(|i| i["name"].as_str().unwrap()).collect()
}
#[tokio::test(flavor = "multi_thread")]
async fn call_hierarchy_lists_callers_with_their_call_sites() {
let (h, _server) = call_hierarchy_harness().await;
let callers = h.json("get_call_hierarchy", json!({"filePath":"src/lib.rs","line":1,"column":9})).await;
assert_eq!(callers["root"]["name"], "price");
assert_eq!(callers["root"]["filePath"], "src/lib.rs");
assert_eq!(callers["root"]["lineText"], "pub fn price(cents: u64) -> u64 {");
assert_eq!(callers["total"], 3);
let main = callers["items"].as_array().unwrap().iter().find(|i| i["name"] == "main").unwrap();
assert_eq!(
main,
&json!({"name":"main","kind":"function","filePath":"src/main.rs",
"startLine":1,"startColumn":4,"endLine":1,"endColumn":8,"lineText":"fn main() {",
"callSites":[{"filePath":"src/main.rs","startLine":2,"startColumn":13,"endLine":2,"endColumn":18,
"lineText":" let a = price(1);"}]})
);
// An item's position is a valid input for the next level.
let main_calls = h
.json(
"get_call_hierarchy",
json!({"filePath":"src/main.rs","line":main["startLine"],"column":main["startColumn"],"direction":"outgoing"}),
)
.await;
assert_eq!(names(&main_calls), ["price", "show"]);
}
#[tokio::test(flavor = "multi_thread")]
async fn outgoing_call_sites_are_in_the_file_of_the_root() {
let (h, _server) = call_hierarchy_harness().await;
// On the call `price(1)` in main.rs: the hierarchy of `price`, declared in lib.rs.
let callees = h
.json("get_call_hierarchy", json!({"filePath":"src/main.rs","line":2,"column":14,"direction":"outgoing"}))
.await;
assert_eq!(callees["root"]["filePath"], "src/lib.rs");
assert_eq!(names(&callees), ["double"]);
assert_eq!(
callees["items"][0]["callSites"],
json!([{"filePath":"src/lib.rs","startLine":2,"startColumn":5,"endLine":2,"endColumn":11,"lineText":" double(cents)"}])
);
let from_main = h
.json("get_call_hierarchy", json!({"filePath":"src/main.rs","line":1,"column":4,"direction":"outgoing"}))
.await;
let price = &from_main["items"][0];
assert_eq!((&price["filePath"], &price["callSites"][0]["filePath"]), (&json!("src/lib.rs"), &json!("src/main.rs")));
assert_eq!(price["callSites"][0]["lineText"], " let a = price(1);");
}
#[tokio::test(flavor = "multi_thread")]
async fn a_position_in_a_function_body_means_that_function() {
let (h, _server) = call_hierarchy_harness().await;
let body = json!({"filePath":"src/main.rs","line":2,"column":5,"direction":"outgoing"});
let callees = h.json("get_call_hierarchy", body).await;
assert_eq!(callees["root"]["name"], "main");
assert_eq!(names(&callees), ["price", "show"]);
let outside = h.error("get_call_hierarchy", json!({"filePath":"src/main.rs","line":6,"column":1})).await;
assert_eq!(outside, "no function or method at 6:1");
}
#[tokio::test(flavor = "multi_thread")]
async fn call_hierarchy_pages_are_sorted_and_scoped() {
let (h, _server) = call_hierarchy_harness().await;
let at = |extra: Value| {
let mut args = json!({"filePath":"src/lib.rs","line":1,"column":9});
args.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
args
};
let first = h.json("get_call_hierarchy", at(json!({"limit":2}))).await;
assert_eq!(names(&first), ["Caller", "helper"]);
assert_eq!(first["items"][0]["filePath"], LIBRARY_URI);
assert!(first["items"][0].get("lineText").is_none(), "{first}");
assert_eq!((&first["more"], &first["nextOffset"]), (&json!(true), &json!(2)));
let next = h.json("get_call_hierarchy", at(json!({"limit":2,"offset":2}))).await;
assert_eq!(names(&next), ["main"]);
let scoped = h.json("get_call_hierarchy", at(json!({"scope":"src"}))).await;
assert_eq!(names(&scoped), ["main"]);
assert_eq!(scoped["total"], 1);
assert_eq!(scoped["root"]["name"], "price", "the root is shown whatever the scope");
}
+234
Переглянути файл
@@ -0,0 +1,234 @@
//! `ui.read-clipboard` (API 1.11) through the `test.clipboard` fixture and a
//! scripted window answering `ClipboardRequested`: commands and view actions the
//! user ran read the window's clipboard, anything unattended is denied.
use base64::Engine;
use ide_host::plugins::*;
use ide_plugin::{HostError, Invocation, Limits, ViewEvent};
use parking_lot::Mutex;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::{Duration, Instant};
const ID: &str = "test.clipboard";
fn fixture_dir() -> PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/clipboard")
}
struct Workspace {
root: PathBuf,
}
impl PluginWorkspace for Workspace {
fn projects(&self) -> Vec<PathBuf> {
vec![self.root.clone()]
}
fn buffer_text(&self, _: &Path) -> Option<String> {
None
}
fn document(&self, _: &Path) -> Option<(u64, String)> {
None
}
fn apply_edits(&self, _: &Path, _: u64, _: &[ide_core::TextEdit], _: bool) -> Result<u64, HostError> {
Err(HostError::NotFound("not open".into()))
}
fn trusted(&self, _: &Path) -> bool {
true
}
fn project_of(&self, _: &str) -> Option<PathBuf> {
Some(self.root.clone())
}
fn publish_diagnostics(&self, _: &str, _: &Path, _: Vec<ide_core::Diagnostic>) -> Result<(), HostError> {
Ok(())
}
}
/// The window: what it answers, and the requests it got (`(window, request id)`).
#[derive(Default)]
struct Window {
answer: Option<ClipboardAnswer>,
/// Answer from this window instead of the one asked.
answer_as: Option<String>,
requests: Vec<(Option<String>, String)>,
}
struct Fixture {
host: Arc<PluginHost>,
window: Arc<Mutex<Window>>,
project: PathBuf,
_tmp: tempfile::TempDir,
}
impl Fixture {
fn new() -> Self {
let tmp = tempfile::tempdir().unwrap();
let project = tmp.path().join("project");
std::fs::create_dir_all(&project).unwrap();
let window = Arc::new(Mutex::new(Window::default()));
let host_slot: Arc<Mutex<Option<std::sync::Weak<PluginHost>>>> = Arc::default();
let (w, slot) = (window.clone(), host_slot.clone());
// Answers on another thread, as the UI does through `plugin_answer_clipboard`.
let sink = Arc::new(move |client: Option<&str>, e: PluginEvent| {
let PluginEvent::ClipboardRequested { request_id, .. } = e else { return };
let (client, w, slot) = (client.map(str::to_owned), w.clone(), slot.clone());
std::thread::spawn(move || {
let (answer, from) = {
let mut w = w.lock();
w.requests.push((client.clone(), request_id.clone()));
(w.answer.clone(), w.answer_as.clone().or(client).unwrap_or_default())
};
let host = slot.lock().as_ref().and_then(std::sync::Weak::upgrade).unwrap();
if let Some(answer) = answer {
host.answer_clipboard(&from, &request_id, answer);
}
});
});
let host = Arc::new(PluginHost::new(tmp.path().join("plugins"), sink, Limits::default()).unwrap());
*host_slot.lock() = Some(Arc::downgrade(&host));
host.set_workspace(Some(Arc::new(Workspace { root: project.clone() })));
host.load_all();
host.startup_finished();
host.install_from_dir(&fixture_dir(), &Consent::all()).unwrap();
Self { host, window, project, _tmp: tmp }
}
fn inv(&self) -> Invocation {
Invocation { client: Some("main".into()), workspace_root: Some(self.project.clone()), ..Invocation::default() }
}
fn answer(&self, answer: ClipboardAnswer) {
self.window.lock().answer = Some(answer);
}
fn read(&self) -> Result<String, String> {
self.host.run_command(ID, "read", None, self.inv()).map(Option::unwrap_or_default).map_err(|e| e.message)
}
/// What the last view action or event handler read.
fn last(&self) -> String {
self.host.run_command(ID, "last", None, self.inv()).unwrap().unwrap_or_default()
}
fn requests(&self) -> usize {
self.window.lock().requests.len()
}
}
fn content(text: Option<&str>, png: Option<&[u8]>) -> ClipboardAnswer {
ClipboardAnswer::Content {
text: text.map(str::to_owned),
png: png.map(|png| base64::engine::general_purpose::STANDARD.encode(png)),
}
}
#[test]
fn a_command_reads_the_text_and_image_of_its_window() {
let f = Fixture::new();
f.answer(content(Some("curl https://example.com"), None));
assert_eq!(f.read().unwrap(), "text=curl https://example.com image=-");
assert_eq!(f.window.lock().requests[0].0.as_deref(), Some("main"), "the invoking window is asked");
f.answer(content(None, Some(&[0x89, b'P', b'N', b'G', 1, 2])));
assert_eq!(f.read().unwrap(), "text=- image=6");
f.answer(content(Some("caption"), Some(&[1, 2, 3])));
assert_eq!(f.read().unwrap(), "text=caption image=3");
// Empty: neither kind, also when the window sends empty strings.
f.answer(content(None, None));
assert_eq!(f.read().unwrap(), "text=- image=-");
f.answer(ClipboardAnswer::Content { text: Some(String::new()), png: Some(String::new()) });
assert_eq!(f.read().unwrap(), "text=- image=-");
}
#[test]
fn refusals_failures_and_oversized_content_are_errors() {
let f = Fixture::new();
f.answer(ClipboardAnswer::Refused);
let err = f.read().unwrap_err();
assert!(err.contains("clipboard.read (the user refused)"), "{err}");
f.answer(ClipboardAnswer::Failed { message: "the WebView refused".into() });
assert!(f.read().unwrap_err().contains("the WebView refused"));
let large = vec![0u8; ide_plugin::MAX_CLIPBOARD_BYTES + 1];
f.answer(content(None, Some(&large)));
assert!(f.read().unwrap_err().contains("16 MiB"));
f.answer(content(Some(&"x".repeat(ide_plugin::MAX_CLIPBOARD_BYTES + 1)), None));
assert!(f.read().unwrap_err().contains("16 MiB"));
}
#[test]
fn reading_needs_its_own_grant() {
let f = Fixture::new();
f.answer(content(Some("secret"), None));
f.host.set_capability(ID, "clipboard.read", false).unwrap();
let err = f.read().unwrap_err();
assert!(err.contains("clipboard.read"), "{err}");
assert_eq!(f.requests(), 0, "the window is not asked");
}
#[test]
fn only_calls_the_user_ran_read_it() {
let f = Fixture::new();
f.answer(content(Some("secret"), None));
let denied = |out: &str| out.starts_with("error: ") && out.contains("clipboard.read");
// A view's button is the user's; a web view message is the page's own.
f.host.view_event(ID, "clipboard", ViewEvent::Button { id: "read".into() }, f.inv()).unwrap();
assert_eq!(f.last(), "text=secret image=-");
assert_eq!(f.requests(), 1);
f.host.view_event(ID, "clipboard", ViewEvent::Message { text: "read".into() }, f.inv()).unwrap();
let last = f.last();
assert!(denied(&last), "{last}");
// An event handler.
let now = Instant::now();
let focused = f.project.join("a.txt").to_string_lossy().into_owned();
f.host.post_events(Some("main"), vec![WorkbenchEvent::EditorFocused(Some(focused))]);
f.host.flush_events_at(now + Duration::from_secs(3));
assert!(f.host.wait_events(Duration::from_secs(10)));
let last = f.last();
assert!(denied(&last), "{last}");
// A command another plugin ran through `command-runner`, and one with no window.
let nested = Invocation { command_chain: vec!["other.plugin".into()], ..f.inv() };
assert!(f.host.run_command(ID, "read", None, nested).unwrap_err().message.contains("clipboard.read"));
let headless = Invocation { client: None, ..f.inv() };
assert!(f.host.run_command(ID, "read", None, headless).unwrap_err().message.contains("clipboard.read"));
assert_eq!(f.requests(), 1, "only the view's button asked the window");
}
#[test]
fn only_the_asked_window_answers() {
let f = Fixture::new();
f.window.lock().answer_as = Some("other".into());
f.answer(content(Some("other window"), None));
let host = f.host.clone();
let inv = f.inv();
let read = std::thread::spawn(move || host.run_command(ID, "read", None, inv));
let started = Instant::now();
while f.requests() == 0 {
assert!(started.elapsed() < Duration::from_secs(10), "the window was not asked");
std::thread::sleep(Duration::from_millis(10));
}
// The other window's answer was ignored, so the call still waits for `main`.
std::thread::sleep(Duration::from_millis(200));
assert!(!read.is_finished());
let request = f.window.lock().requests[0].1.clone();
assert!(f.host.answer_clipboard("main", &request, content(Some("main window"), None)));
assert_eq!(read.join().unwrap().unwrap().as_deref(), Some("text=main window image=-"));
}
#[test]
fn the_capability_needs_api_1_11() {
let tmp = tempfile::tempdir().unwrap();
let pkg = tmp.path().join("clipboard");
std::fs::create_dir_all(pkg.join("dist")).unwrap();
let manifest = std::fs::read_to_string(fixture_dir().join("plugin.toml")).unwrap();
std::fs::write(pkg.join("plugin.toml"), manifest.replace("^1.11", "^1.10")).unwrap();
std::fs::copy(fixture_dir().join("dist/plugin.wasm"), pkg.join("dist/plugin.wasm")).unwrap();
let host =
PluginHost::new(tmp.path().join("plugins"), Arc::new(|_: Option<&str>, _| {}), Limits::default()).unwrap();
let err = host.install_from_dir(&pkg, &Consent::all()).unwrap_err();
assert!(err.message.contains("new in plugin API 1.11"), "{err:?}");
}
+32
Переглянути файл
@@ -2204,6 +2204,10 @@ fn java_agent_loads_only_while_granted_and_unchanged() {
let info = f.host.install_from_dir(&pkg, &Consent::default()).unwrap();
assert_eq!(info.status, PluginStatus::Static, "{:?}", info.error);
assert!(info.contributions.iter().any(|c| c.point == "javaAgents" && c.label == "fixture agent.jar=mode=test"));
let agent = info.java_agent.clone().expect("agent metadata");
assert_eq!(agent.file_name, "fixture agent.jar");
assert_eq!(agent.args.as_deref(), Some("mode=test"));
assert!(!agent.approved);
let source = f.host.java_agents();
let launch = || {
let agents = ide_run::java_agent::approved(&source.agents());
@@ -2217,6 +2221,7 @@ fn java_agent_loads_only_while_granted_and_unchanged() {
// Granted: the installed jar with its arguments, one argument after the VM options.
let info = f.host.set_capability("java-agent", "java.agent", true).unwrap();
assert!(info.capabilities.iter().any(|c| c.id == "java.agent" && c.granted));
assert!(info.java_agent.as_ref().is_some_and(|agent| agent.approved));
let jar = dunce::canonicalize(f.installed("java-agent").join("agent/fixture agent.jar")).unwrap();
let option = format!("-javaagent:{}=mode=test", jar.display());
let mut with_agent = plain.clone();
@@ -2228,7 +2233,11 @@ fn java_agent_loads_only_while_granted_and_unchanged() {
let (args, notes) = launch();
assert_eq!(args, plain);
assert!(notes.len() == 1 && notes[0].contains("changed since it was approved"), "{notes:?}");
let changed = f.host.info_of("java-agent").unwrap();
assert!(!changed.java_agent.as_ref().unwrap().approved, "Settings must show the changed jar");
f.host.set_capability("java-agent", "java.agent", false).unwrap();
f.host.set_capability("java-agent", "java.agent", true).unwrap();
assert!(f.host.info_of("java-agent").unwrap().java_agent.as_ref().is_some_and(|a| a.approved));
assert_eq!(launch(), (with_agent.clone(), vec![]));
// Revoked, then the plugin disabled: no agent either way.
@@ -5275,6 +5284,29 @@ fn plugin_readonly_fields_and_table_row_extensions_round_trip() {
}
}
#[test]
fn document_changes_reach_plugins_relative_to_the_project() {
let f = fixture(Limits::default());
f.install(&sample("path-events"));
f.run("test.path-events", "count", None).unwrap();
let deliver = |path: &str| {
let change = ide_plugin::DocumentChanged {
path: to_ipc(&f.project.join(path)),
base_version: 1,
version: 2,
changes: Vec::new(),
};
f.host.post_events(Some("main"), vec![WorkbenchEvent::DocumentChanged(change)]);
f.host.flush_events_at(Instant::now() + Duration::from_secs(3));
assert!(f.host.wait_events(Duration::from_secs(10)));
};
deliver("src/main.rs");
assert_eq!(f.run("test.path-events", "document", None).unwrap(), None, "outside the subscribed paths");
// Queued with the absolute path, filtered again at delivery, handed over project-relative.
deliver("config/app.yaml");
assert_eq!(f.run("test.path-events", "document", None).unwrap().as_deref(), Some("config/app.yaml"));
}
#[test]
fn path_filtered_events_do_not_wake_idle_plugins_and_recheck_queued_filters() {
let f = fixture(Limits { idle_timeout: Some(Duration::from_millis(100)), ..Limits::default() });
+2
Переглянути файл
@@ -176,7 +176,9 @@ async fn properties_search_git_and_document_coordinates_agree() {
vec![ide_search::ReplaceTarget {
path: closed_path.clone().into(),
only: Some(vec![ide_core::Pos { line: 0, col: 10 }]),
skip: None,
}],
false,
ide_host::ops::Channel::new(|_| {}),
)
.await
+32
Переглянути файл
@@ -1080,3 +1080,35 @@ async fn cancelling_one_request_does_not_interrupt_another_running_command() {
assert_eq!(plugins.host().info_of("jobs").unwrap().stats.crashes, 0);
plugins.host().shutdown();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn a_remote_command_reads_the_clipboard_of_the_desktop_window() {
let (_tmp, plugins, peer, client) = command_rpc_fixture().await;
plugins.host().install_from_dir(&fixture("clipboard"), &Consent::all()).unwrap();
let read = tokio::spawn({
let peer = peer.clone();
async move {
invoke(&peer, "plugin_run_command", json!({ "pluginId": "test.clipboard", "commandId": "read" })).await
}
});
until("the server asks the window for its clipboard", 5, || {
client.plugin_events.lock().iter().any(|m| matches!(m.event, PluginEvent::ClipboardRequested { .. }))
})
.await;
let (window, request) = client
.plugin_events
.lock()
.iter()
.find_map(|m| match &m.event {
PluginEvent::ClipboardRequested { request_id, .. } => Some((m.window.clone(), request_id.clone())),
_ => None,
})
.unwrap();
assert_eq!(window.as_deref(), Some("main"), "the invoking window reads its own clipboard");
let answer = json!({ "kind": "content", "text": "from the desktop", "png": null });
let answered = invoke(&peer, "plugin_answer_clipboard", json!({ "requestId": request, "answer": answer }));
assert_eq!(answered.await.unwrap(), true);
let reply = tokio::time::timeout(Duration::from_secs(5), read).await.unwrap().unwrap().unwrap();
assert_eq!(reply, "text=from the desktop image=-");
plugins.host().shutdown();
}
+148
Переглянути файл
@@ -0,0 +1,148 @@
//! Replace All when the search hit its match limit (#4083): every match in the
//! scope is replaced, not just the listed ones.
use ide_core::{NullSink, Pos, RequestId};
use ide_host::{Host, HostConfig, ops};
use ide_search::{ReplaceEvent, ReplaceSummary, ReplaceTarget, SearchQuery};
use std::sync::{Arc, Mutex};
fn query(pattern: &str, is_regex: bool) -> SearchQuery {
serde_json::from_value(serde_json::json!({"pattern": pattern, "isRegex": is_regex, "caseSensitive": true, "wholeWord": false, "include": [], "exclude": [], "scope": {"kind": "project"}, "maxMatches": 2000})).unwrap()
}
struct Case {
name: &'static str,
files: Vec<(&'static str, String)>,
pattern: &'static str,
is_regex: bool,
replacement: &'static str,
/// `(file, positions)` sent as targets: `skip` with `all_in_scope`, else `only`.
targets: Vec<(&'static str, Vec<Pos>)>,
all_in_scope: bool,
expected: Vec<(&'static str, String)>,
replaced: u32,
}
fn lines(n: usize, text: &str) -> String {
format!("{text}\n").repeat(n)
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn replace_all_covers_matches_past_the_limit() {
let cases = vec![
Case {
name: "one file, 2001 matches (the report)",
files: vec![("repeated.txt", lines(2001, "CAP_PROBE"))],
pattern: "CAP_PROBE",
is_regex: false,
replacement: "CAP_CHANGED",
targets: vec![],
all_in_scope: true,
expected: vec![("repeated.txt", lines(2001, "CAP_CHANGED"))],
replaced: 2001,
},
Case {
name: "several files, unlisted ones too",
files: vec![("a.txt", lines(1500, "CAP")), ("b.txt", lines(1500, "CAP")), ("sub/c.txt", "x CAP\n".into())],
pattern: "CAP",
is_regex: false,
replacement: "Z",
targets: vec![],
all_in_scope: true,
expected: vec![("a.txt", lines(1500, "Z")), ("b.txt", lines(1500, "Z")), ("sub/c.txt", "x Z\n".into())],
replaced: 3001,
},
Case {
name: "excluded usages are kept",
files: vec![("repeated.txt", lines(2001, "CAP_PROBE"))],
pattern: "CAP_PROBE",
is_regex: false,
replacement: "CAP_CHANGED",
targets: vec![("repeated.txt", vec![Pos::new(0, 0), Pos::new(2000, 0)])],
all_in_scope: true,
expected: vec![("repeated.txt", format!("CAP_PROBE\n{}CAP_PROBE\n", lines(1999, "CAP_CHANGED")))],
replaced: 1999,
},
Case {
name: "regex with groups",
files: vec![("repeated.txt", lines(2001, "CAP_PROBE"))],
pattern: r"CAP_(\w+)",
is_regex: true,
replacement: "${1}_CAP",
targets: vec![],
all_in_scope: true,
expected: vec![("repeated.txt", lines(2001, "PROBE_CAP"))],
replaced: 2001,
},
Case {
name: "Replace Selected keeps to the selected usages",
files: vec![("repeated.txt", lines(3, "CAP_PROBE"))],
pattern: "CAP_PROBE",
is_regex: false,
replacement: "CAP_CHANGED",
targets: vec![("repeated.txt", vec![Pos::new(1, 0)])],
all_in_scope: false,
expected: vec![("repeated.txt", "CAP_PROBE\nCAP_CHANGED\nCAP_PROBE\n".into())],
replaced: 1,
},
];
for case in cases {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("project");
for (path, text) in &case.files {
let path = root.join(path);
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
std::fs::write(path, text).unwrap();
}
let host = Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("data"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(NullSink)),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
host.trust.decide(&root, true, false).unwrap();
host.open_project("main", &root).unwrap();
let targets = case
.targets
.iter()
.map(|(path, at)| {
let path = root.join(path).into();
if case.all_in_scope {
ReplaceTarget { path, only: None, skip: Some(at.clone()) }
} else {
ReplaceTarget { path, only: Some(at.clone()), skip: None }
}
})
.collect();
let summary = Arc::new(Mutex::new(ReplaceSummary::default()));
let out = summary.clone();
ops::search::replace_in_files(
&host,
"main",
RequestId::next(),
query(case.pattern, case.is_regex),
case.replacement.into(),
false,
targets,
case.all_in_scope,
ops::Channel::new(move |e| {
if let ReplaceEvent::Done { summary } = e {
*out.lock().unwrap() = summary;
}
}),
)
.await
.unwrap();
for (path, text) in &case.expected {
assert_eq!(&std::fs::read_to_string(root.join(path)).unwrap(), text, "{}: {path}", case.name);
}
assert_eq!(summary.lock().unwrap().replacements, case.replaced, "{}", case.name);
host.close_project("main");
}
}
+461 -33
Переглянути файл
@@ -68,7 +68,7 @@ pub(crate) struct Shared {
pub store: Option<Store>,
pub indexing: AtomicBool,
pub cancelled: AtomicBool,
/// Files whose content was (re)read and parsed; observability for tests.
/// Non-cached content reads, including binary/unsupported files; used by tests.
pub parsed: std::sync::atomic::AtomicUsize,
queue: Mutex<Queue>,
wake: Condvar,
@@ -160,14 +160,38 @@ impl Shared {
q.busy = true;
}
if scan {
let startup_started = Instant::now();
// A warm start can trust the snapshot when neither the scope nor any
// directory/file metadata changed. Rebuilding the walk's file list is
// the expensive part; validate the flat manifest first.
if !self.try_fast_start() {
let snapshot_started = Instant::now();
let fast = self.try_fast_start();
let snapshot_elapsed = snapshot_started.elapsed();
if !fast {
let snapshot_guard = SystemTime::now();
let walk_started = Instant::now();
let found = self.walk_roots(None);
let walk_elapsed = walk_started.elapsed();
let hydration_started = Instant::now();
self.load_persisted(&found);
let hydration_elapsed = hydration_started.elapsed();
self.full_scan(Some(found), snapshot_guard);
if !self.is_cancelled() {
tracing::info!(
mode = "fallback",
snapshot_attempt_ms = snapshot_elapsed.as_millis() as u64,
walk_ms = walk_elapsed.as_millis() as u64,
hydration_ms = hydration_elapsed.as_millis() as u64,
elapsed_ms = startup_started.elapsed().as_millis() as u64,
"index startup completed"
);
}
} else if !self.is_cancelled() {
tracing::info!(
mode = "snapshot",
elapsed_ms = startup_started.elapsed().as_millis() as u64,
"index startup completed"
);
}
} else {
self.indexing.store(false, Ordering::SeqCst);
@@ -234,6 +258,7 @@ impl Shared {
return false;
}
let root = filter.root();
let validation_started = Instant::now();
for i in 0..snapshot.dirs_len() {
let rel = snapshot.dir(i);
let path = if rel.is_empty() { root.to_owned() } else { root.join(rel) };
@@ -265,6 +290,7 @@ impl Shared {
return false;
}
}
let validation_elapsed = validation_started.elapsed();
let build_started = Instant::now();
let entries: Vec<Option<(FileEntry, Vec<StoredSymbol>)>> = INDEX_POOL.install(|| {
(0..snapshot.len())
@@ -302,9 +328,16 @@ impl Shared {
d.load_bulk(entries, dirs);
drop(d);
tracing::info!(
"index snapshot: warm start in {:?} (load {loaded:?}, validate/build {built:?}, insert {:?})",
started.elapsed(),
insert_started.elapsed()
mode = "snapshot",
snapshot_hydrated = snapshot.len(),
discovered = 0usize,
symbol_extractions = 0usize,
load_ms = loaded.as_millis() as u64,
directory_validation_ms = validation_elapsed.as_millis() as u64,
file_validation_build_ms = built.as_millis() as u64,
insert_ms = insert_started.elapsed().as_millis() as u64,
elapsed_ms = started.elapsed().as_millis() as u64,
"index snapshot hydrated"
);
#[cfg(test)]
eprintln!(
@@ -441,7 +474,7 @@ impl Shared {
self.scan(None, found, guard);
}
fn scan(&self, dirs: Option<&[PathBuf]>, prewalked: Option<Vec<Found>>, guard: SystemTime) {
fn scan(&self, dirs: Option<&[PathBuf]>, prewalked: Option<Vec<Found>>, guard: SystemTime) -> Option<ScanCounts> {
let started = Instant::now();
self.indexing.store(true, Ordering::SeqCst);
self.emit_state();
@@ -457,10 +490,12 @@ impl Shared {
let filter = self.filter();
let walk_started = Instant::now();
let was_prewalked = prewalked.is_some();
let found = prewalked.unwrap_or_else(|| self.walk_roots(dirs));
let walk = walk_started.elapsed();
if self.is_cancelled() {
return self.end_scan(task);
self.end_scan(task);
return None;
}
let classify_started = Instant::now();
let seen: HashSet<&Path> = found.iter().map(|f| f.path.as_path()).collect();
@@ -487,6 +522,7 @@ impl Shared {
self.persist(&[], &stale, false);
let total = todo.len();
let update_started = Instant::now();
let mut laps = ChunkLaps::default();
{
// One streaming parallel pass: parse on `INDEX_POOL` without
@@ -546,11 +582,14 @@ impl Shared {
laps.extract = pass_started.elapsed();
}
if self.is_cancelled() {
return self.end_scan(task);
self.end_scan(task);
return None;
}
let durable_started = Instant::now();
self.persist(&[], &[], true);
let durable = durable_started.elapsed();
let update_elapsed = update_started.elapsed();
let snapshot_started = Instant::now();
if let Some(store) = &self.store {
let recent: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.store_key(p)).collect();
let d = self.data.read();
@@ -563,6 +602,7 @@ impl Shared {
tracing::warn!("index recent snapshot: {e}");
}
}
let snapshot_elapsed = snapshot_started.elapsed();
*self.snapshot_due.lock() = None;
self.indexing.store(false, Ordering::SeqCst);
self.sink.emit(IdeEvent::Task {
@@ -574,20 +614,47 @@ impl Shared {
cancellable: false,
});
self.emit_state();
if self.is_cancelled() {
return None;
}
laps.outcomes.not_processed += total - laps.outcomes.total();
let counts = ScanCounts {
discovered: found.len(),
metadata_reused: found.len() - total,
scheduled: total,
outcomes: laps.outcomes,
};
let outcomes = &counts.outcomes;
let d = self.data.read();
tracing::info!(
"indexed {} files ({} parsed, {} symbols) in {:?} (walk {:?}, classify {:?}, extract {:?}, insert {:?}, persist {:?}, durable {:?})",
d.file_count,
total,
d.symbol_count,
started.elapsed(),
walk,
classify,
laps.extract,
laps.insert,
laps.persist,
durable
scope = if dirs.is_some() { "subtree" } else { "full" },
files = d.file_count,
symbols = d.symbol_count,
discovered = counts.discovered,
metadata_reused = counts.metadata_reused,
scheduled = counts.scheduled,
hash_reused = outcomes.hash_reused,
symbol_extractions = outcomes.symbol_extractions,
ignored = outcomes.ignored,
oversized = outcomes.oversized,
binary = outcomes.binary,
unsupported = outcomes.unsupported,
read_failed = outcomes.read_failed,
not_processed = outcomes.not_processed,
prewalked = was_prewalked,
walk_ms = walk.as_millis() as u64,
classify_ms = classify.as_millis() as u64,
// Pipeline and update wall times overlap insert/persist; do not sum these fields.
extract_pipeline_ms = laps.extract.as_millis() as u64,
insert_ms = laps.insert.as_millis() as u64,
persist_ms = laps.persist.as_millis() as u64,
durable_ms = durable.as_millis() as u64,
update_ms = update_elapsed.as_millis() as u64,
snapshot_write_ms = snapshot_elapsed.as_millis() as u64,
elapsed_ms = started.elapsed().as_millis() as u64,
"index scan completed"
);
Some(counts)
}
/// Extracts records in parallel, then publishes them to memory and disk.
@@ -599,6 +666,7 @@ impl Shared {
files.par_iter().filter_map(|(f, prev_hash)| self.parse_found(f, *prev_hash, &filter)).collect()
});
laps.extract = started.elapsed();
laps.outcomes.not_processed = files.len() - extracted.len();
if extracted.is_empty() {
return laps;
}
@@ -622,9 +690,9 @@ impl Shared {
let key = filter.store_key(&f.path);
let outcome = match self.extract(f, prev_hash) {
Extracted::Unchanged => ParsedOutcome::Unchanged { mtime: f.mtime, size: f.size, ignored: f.ignored },
Extracted::New(rec) => {
Extracted::New(rec, extraction) => {
let bytes = key.as_ref().and_then(|_| postcard::to_allocvec(&rec).ok());
ParsedOutcome::New { rec, bytes }
ParsedOutcome::New { rec, bytes, extraction }
}
};
Some(ParsedFile { rel, key, outcome, path: f.path.clone() })
@@ -640,7 +708,8 @@ impl Shared {
for out in batch {
let ParsedFile { rel, key, outcome, path } = out;
match outcome {
ParsedOutcome::New { rec, bytes } => {
ParsedOutcome::New { rec, bytes, extraction } => {
laps.outcomes.record(extraction);
if let (Some(key), Some(bytes)) = (key, bytes) {
puts.push((key, bytes));
}
@@ -658,10 +727,13 @@ impl Shared {
d.insert(e, symbols);
}
for r in refreshes {
if let Some(rec) = d.refresh_metadata(&r.path, r.mtime, r.size, r.ignored)
&& let Some(key) = r.key
{
refreshed_records.push((key, rec));
if let Some(rec) = d.refresh_metadata(&r.path, r.mtime, r.size, r.ignored) {
laps.outcomes.record(Extraction::HashReused);
if let Some(key) = r.key {
refreshed_records.push((key, rec));
}
} else {
laps.outcomes.not_processed += 1;
}
}
}
@@ -726,15 +798,18 @@ impl Shared {
fn extract(&self, f: &Found, prev_hash: Option<[u8; 32]>) -> Extracted {
let mut rec = FileRecord { mtime: f.mtime, size: f.size, ignored: f.ignored, ..Default::default() };
if f.ignored || f.size > MAX_SYMBOL_FILE {
return Extracted::New(rec);
if f.ignored {
return Extracted::New(rec, Extraction::Ignored);
}
if f.size > MAX_SYMBOL_FILE {
return Extracted::New(rec, Extraction::Oversized);
}
let mut bytes = Vec::with_capacity(f.size as usize);
match std::fs::File::open(&f.path).and_then(|mut file| file.read_to_end(&mut bytes)) {
Ok(_) => {}
Err(e) => {
tracing::debug!("index: cannot read {}: {e}", f.path.display());
return Extracted::New(rec);
return Extracted::New(rec, Extraction::ReadFailed);
}
}
rec.hash = *blake3::hash(&bytes).as_bytes();
@@ -743,7 +818,7 @@ impl Shared {
}
self.parsed.fetch_add(1, Ordering::Relaxed);
if bytes[..bytes.len().min(8192)].contains(&0) {
return Extracted::New(rec);
return Extracted::New(rec, Extraction::Binary);
}
let text = String::from_utf8_lossy(&bytes);
let lang = self.languages.detect(&f.path, Some(first_line(&text)));
@@ -760,8 +835,9 @@ impl Shared {
bases: t.bases,
})
.collect();
return Extracted::New(rec, Extraction::Symbols);
}
Extracted::New(rec)
Extracted::New(rec, Extraction::Unsupported)
}
fn process(&self, jobs: Vec<Job>) {
@@ -938,7 +1014,7 @@ fn first_line(text: &str) -> &str {
enum Extracted {
/// Content hash matches the indexed version.
Unchanged,
New(FileRecord),
New(FileRecord, Extraction),
}
/// Wall-time laps of one `index_files` chunk, accumulated by the scan.
@@ -947,6 +1023,7 @@ struct ChunkLaps {
extract: Duration,
insert: Duration,
persist: Duration,
outcomes: ExtractionCounts,
}
impl ChunkLaps {
@@ -954,6 +1031,7 @@ impl ChunkLaps {
self.extract += other.extract;
self.insert += other.insert;
self.persist += other.persist;
self.outcomes.add(other.outcomes);
}
}
@@ -967,7 +1045,7 @@ struct MetadataRefresh {
enum ParsedOutcome {
Unchanged { mtime: u64, size: u64, ignored: bool },
New { rec: FileRecord, bytes: Option<Vec<u8>> },
New { rec: FileRecord, bytes: Option<Vec<u8>>, extraction: Extraction },
}
/// One file parsed off the index thread: its outcome ready to publish, with new
@@ -980,6 +1058,356 @@ struct ParsedFile {
path: PathBuf,
}
/// Mutually exclusive outcomes for this batch, not all files in the index. "Symbols"
/// means tags() was called, even when no symbols were found.
#[derive(Clone, Copy)]
enum Extraction {
HashReused,
Symbols,
Ignored,
Oversized,
Binary,
Unsupported,
ReadFailed,
}
#[derive(Default, Debug, PartialEq, Eq)]
struct ExtractionCounts {
hash_reused: usize,
symbol_extractions: usize,
ignored: usize,
oversized: usize,
binary: usize,
unsupported: usize,
read_failed: usize,
/// Cancellation, a changed root configuration, or a concurrently removed entry.
not_processed: usize,
}
impl ExtractionCounts {
fn total(&self) -> usize {
self.hash_reused
+ self.symbol_extractions
+ self.ignored
+ self.oversized
+ self.binary
+ self.unsupported
+ self.read_failed
+ self.not_processed
}
fn record(&mut self, outcome: Extraction) {
*match outcome {
Extraction::HashReused => &mut self.hash_reused,
Extraction::Symbols => &mut self.symbol_extractions,
Extraction::Ignored => &mut self.ignored,
Extraction::Oversized => &mut self.oversized,
Extraction::Binary => &mut self.binary,
Extraction::Unsupported => &mut self.unsupported,
Extraction::ReadFailed => &mut self.read_failed,
} += 1;
}
fn add(&mut self, other: Self) {
self.hash_reused += other.hash_reused;
self.symbol_extractions += other.symbol_extractions;
self.ignored += other.ignored;
self.oversized += other.oversized;
self.binary += other.binary;
self.unsupported += other.unsupported;
self.read_failed += other.read_failed;
self.not_processed += other.not_processed;
}
}
struct ScanCounts {
/// Files yielded by the filtered walker, not every file on disk.
discovered: usize,
/// Metadata matched an in-memory entry (possibly loaded from disk cache).
metadata_reused: usize,
scheduled: usize,
outcomes: ExtractionCounts,
}
#[cfg(test)]
mod metric_tests {
use super::*;
use std::sync::Arc;
fn index_files<'a>(index: &Shared, files: impl Iterator<Item = &'a Found>, force: bool) -> ExtractionCounts {
let files: Vec<_> = files
.map(|f| {
let hash = if force || f.ignored { None } else { index.data.read().get(&f.path).map(|e| e.hash) };
(f.clone(), hash)
})
.collect();
index.index_files(&files).outcomes
}
fn shared(root: &Path) -> Shared {
Shared::new(
PathFilter::new(root, &crate::IndexRoots::from(Vec::new()), &[]),
Arc::new(LanguageRegistry::load(None).unwrap()),
Arc::new(Syntax::new()),
Arc::new(ide_core::NullSink),
None,
)
}
#[test]
fn streaming_scan_counts_full_batch_and_tail() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
let shared = shared(&root);
let count = SCAN_BATCH + 3;
for i in 0..count {
std::fs::write(root.join(format!("file_{i}.unknown")), "plain").unwrap();
}
let cold = shared.scan(None, None, SystemTime::now()).unwrap();
assert_eq!((cold.discovered, cold.metadata_reused, cold.scheduled), (count, 0, count));
assert_eq!(cold.outcomes, ExtractionCounts { unsupported: count, ..Default::default() });
assert_eq!(shared.data.read().file_count as usize, count);
let hot = shared.scan(None, None, SystemTime::now()).unwrap();
assert_eq!((hot.discovered, hot.metadata_reused, hot.scheduled), (count, count, 0));
assert_eq!(hot.outcomes.total(), 0);
}
#[test]
fn removed_entry_is_not_counted_as_hash_reuse() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
let shared = shared(&root);
let path = root.join("main.rs");
std::fs::write(&path, "fn main() {}").unwrap();
shared.scan(None, None, SystemTime::now()).unwrap();
let (found, hash) = {
let data = shared.data.read();
let e = data.get(&path).unwrap();
(Found { path: path.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored }, e.hash)
};
let parsed = shared.parse_found(&found, Some(hash), &shared.filter()).unwrap();
shared.data.write().remove(&path).unwrap();
let counts = shared.publish(std::iter::once(parsed)).outcomes;
assert_eq!(counts, ExtractionCounts { not_processed: 1, ..Default::default() });
assert_eq!(shared.data.read().file_count, 0);
}
#[test]
fn scan_distinguishes_cold_metadata_and_hash_reuse() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
let path = root.join("main.rs");
std::fs::write(&path, "fn main() {}\n").unwrap();
let shared = shared(&root);
let cold = shared.scan(None, None, SystemTime::now()).unwrap();
assert_eq!((cold.discovered, cold.metadata_reused, cold.scheduled), (1, 0, 1));
assert_eq!(cold.outcomes, ExtractionCounts { symbol_extractions: 1, ..Default::default() });
let hot = shared.scan(None, None, SystemTime::now()).unwrap();
assert_eq!((hot.discovered, hot.metadata_reused, hot.scheduled), (1, 1, 0));
assert_eq!(hot.outcomes, ExtractionCounts::default());
// Force a metadata mismatch without a timestamp-resolution-dependent sleep.
let mut rec = {
let data = shared.data.read();
data.record(data.get(&path).unwrap())
};
rec.mtime = rec.mtime.wrapping_add(1);
let (entry, symbols) = FileEntry::new(path.clone(), "main.rs".into(), rec);
shared.data.write().insert(entry, symbols);
let touched = shared.scan(None, None, SystemTime::now()).unwrap();
assert_eq!((touched.discovered, touched.metadata_reused, touched.scheduled), (1, 0, 1));
assert_eq!(touched.outcomes, ExtractionCounts { hash_reused: 1, ..Default::default() });
assert_eq!(shared.data.read().symbol_count, 1);
}
#[test]
fn extraction_outcomes_are_exclusive_and_forced_parsing_is_counted() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
let shared = shared(&root);
let mut found = Vec::new();
for (name, contents, ignored, size) in [
("source.rs", "fn source() {}", false, 14),
("ignored.rs", "fn hidden() {}", true, 14),
("huge.rs", "", false, MAX_SYMBOL_FILE + 1),
("binary.rs", "\0", false, 1),
("plain.unknown", "plain", false, 5),
("missing.rs", "", false, 0),
] {
let path = root.join(name);
if name != "missing.rs" {
std::fs::write(&path, contents).unwrap();
}
found.push(Found { path, mtime: 0, size, ignored });
}
let counts = index_files(&shared, found.iter(), false);
assert_eq!(
counts,
ExtractionCounts {
symbol_extractions: 1,
ignored: 1,
oversized: 1,
binary: 1,
unsupported: 1,
read_failed: 1,
hash_reused: 0,
not_processed: 0,
}
);
assert_eq!(shared.data.read().file_count as usize, found.len());
assert_eq!(index_files(&shared, found[..1].iter(), false).hash_reused, 1);
assert_eq!(index_files(&shared, found[..1].iter(), true).symbol_extractions, 1);
}
#[test]
fn reopened_cache_counts_metadata_reuse() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().join("project");
std::fs::create_dir(&root).unwrap();
let root = dunce::canonicalize(root).unwrap();
std::fs::write(root.join("main.rs"), "fn main() {}\n").unwrap();
let cache = dir.path().join("cache");
{
let mut index = shared(&root);
index.store = Some(Store::open(&cache, &root, "metrics-test").unwrap());
assert_eq!(index.scan(None, None, SystemTime::now()).unwrap().outcomes.symbol_extractions, 1);
}
let mut index = shared(&root);
index.store = Some(Store::open(&cache, &root, "metrics-test").unwrap());
let found = index.walk_roots(None);
index.load_persisted(&found);
let counts = index.scan(None, Some(found), SystemTime::now()).unwrap();
assert_eq!((counts.discovered, counts.metadata_reused, counts.scheduled), (1, 1, 0));
assert_eq!(counts.outcomes, ExtractionCounts::default());
assert_eq!(index.data.read().symbol_count, 1);
}
#[test]
fn warm_snapshot_hydrates_without_symbol_extraction() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().join("project");
std::fs::create_dir(&root).unwrap();
let root = dunce::canonicalize(root).unwrap();
std::fs::write(root.join("main.rs"), "fn main() {}\n").unwrap();
let cache = dir.path().join("cache");
{
let mut index = shared(&root);
index.store = Some(Store::open(&cache, &root, "metrics-test").unwrap());
assert_eq!(index.scan(None, None, SystemTime::now()).unwrap().outcomes.symbol_extractions, 1);
}
let mut index = shared(&root);
index.store = Some(Store::open(&cache, &root, "metrics-test").unwrap());
assert!(index.try_fast_start());
assert_eq!(index.parsed.load(Ordering::Relaxed), 0);
assert_eq!(index.data.read().file_count, 1);
assert_eq!(index.data.read().symbol_count, 1);
}
#[test]
fn cancelled_warm_start_does_not_log_completion() {
struct CompletionCounter(Arc<std::sync::atomic::AtomicUsize>);
impl tracing::Subscriber for CompletionCounter {
fn enabled(&self, _: &tracing::Metadata<'_>) -> bool {
true
}
fn new_span(&self, _: &tracing::span::Attributes<'_>) -> tracing::span::Id {
tracing::span::Id::from_u64(1)
}
fn record(&self, _: &tracing::span::Id, _: &tracing::span::Record<'_>) {}
fn record_follows_from(&self, _: &tracing::span::Id, _: &tracing::span::Id) {}
fn enter(&self, _: &tracing::span::Id) {}
fn exit(&self, _: &tracing::span::Id) {}
fn event(&self, event: &tracing::Event<'_>) {
struct Message(bool);
impl tracing::field::Visit for Message {
fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
if field.name() == "message" && format!("{value:?}").contains("index startup completed") {
self.0 = true;
}
}
}
let mut message = Message(false);
event.record(&mut message);
if message.0 {
self.0.fetch_add(1, Ordering::Relaxed);
}
}
}
let dir = tempfile::tempdir().unwrap();
let root = dir.path().join("project");
std::fs::create_dir(&root).unwrap();
let root = dunce::canonicalize(root).unwrap();
std::fs::write(root.join("main.rs"), "fn main() {}\n").unwrap();
let cache = dir.path().join("cache");
{
let mut index = shared(&root);
index.store = Some(Store::open(&cache, &root, "metrics-test").unwrap());
index.scan(None, None, SystemTime::now()).unwrap();
}
let mut index = shared(&root);
index.store = Some(Store::open(&cache, &root, "metrics-test").unwrap());
let count = Arc::new(std::sync::atomic::AtomicUsize::new(0));
index.cancel();
tracing::subscriber::with_default(CompletionCounter(count.clone()), || {
tracing::info!("index startup completed");
assert_eq!(count.swap(0, Ordering::Relaxed), 1);
index.run(true);
});
assert_eq!(index.parsed.load(Ordering::Relaxed), 0);
assert_eq!(index.data.read().file_count, 1);
assert_eq!(count.load(Ordering::Relaxed), 0);
}
#[test]
fn files_outside_current_scope_and_cancelled_batches_are_accounted_for() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().join("project");
std::fs::create_dir(&root).unwrap();
let index = shared(&root);
// A scan can retain Found values from a root removed by set_scope.
let outside = Found { path: dir.path().join("outside.rs"), mtime: 0, size: 0, ignored: false };
assert_eq!(
index_files(&index, [&outside].into_iter(), false),
ExtractionCounts { not_processed: 1, ..Default::default() }
);
index.cancel();
let inside = Found { path: root.join("inside.rs"), mtime: 0, size: 0, ignored: false };
assert_eq!(
index_files(&index, [&inside].into_iter(), false),
ExtractionCounts { not_processed: 1, ..Default::default() }
);
}
#[test]
fn cancellation_during_final_notifications_suppresses_completion() {
let dir = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(dir.path()).unwrap();
std::fs::write(root.join("source.rs"), "fn source() {}").unwrap();
let index: Arc<Shared> = Arc::new_cyclic(|weak: &std::sync::Weak<Shared>| {
let mut index = shared(&root);
let weak = weak.clone();
index.sink = Arc::new(move |event| {
if matches!(event, IdeEvent::Task { done: true, .. }) {
weak.upgrade().unwrap().cancel();
}
});
index
});
assert!(index.scan(None, None, SystemTime::now()).is_none());
assert!(index.is_cancelled());
assert!(!index.indexing.load(Ordering::Relaxed));
assert_eq!(index.data.read().file_count, 1);
}
#[test]
fn cancelled_scan_does_not_report_completion() {
let dir = tempfile::tempdir().unwrap();
let shared = shared(dir.path());
shared.cancel();
assert!(shared.scan(None, None, SystemTime::now()).is_none());
assert!(!shared.indexing.load(Ordering::Relaxed));
}
}
#[cfg(test)]
mod tests {
use crate::data::safe_rel;
+3 -2
Переглянути файл
@@ -406,13 +406,14 @@ impl Peer {
// would (`PATH` × `PATHEXT`, e.g. `codex` → `codex.cmd`) first.
let resolved = resolve_spawn_program(command, env);
let mut cmd = tokio::process::Command::new(&resolved);
// The working directory first: it picks the project's environment.
cmd.current_dir(cwd);
ide_core::process::prepare(cmd.as_std_mut());
// Wrappers (`npx`, `codex.cmd`, launcher scripts) start the real server as a child:
// stopping the connection stops the whole tree.
ide_core::process::own_group(cmd.as_std_mut());
cmd.args(args)
.current_dir(cwd)
.envs(ide_core::process::shell_env())
.envs(ide_core::process::shell_env_in(cwd))
.envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())))
.stdin(Stdio::piped())
.stdout(Stdio::piped())
+1
Переглянути файл
@@ -6,6 +6,7 @@ edition.workspace = true
license.workspace = true
[dependencies]
dunce.workspace = true
ide-core.workspace = true
ide-extension.workspace = true
ide-text.workspace = true
+1 -1
Переглянути файл
@@ -18,7 +18,7 @@ mod markers;
pub mod plugin_point;
mod registry;
mod syntax;
pub use markers::{arduino_sketch_root, is_arduino_sketch_dir, marked_root};
pub use markers::{arduino_sketch_root, is_arduino_sketch_dir, marked_root, project_spelling};
pub use plugin_point::PluginLanguages;
pub use registry::{FileTypes, LanguageRegistry};
pub use syntax::{
+15
Переглянути файл
@@ -2,8 +2,23 @@
//! framework's project there (`Cargo.toml`, `angular.json`). Language server
//! roots (`root-markers`) and framework modes (`framework-ui-modes`) share them.
use std::borrow::Cow;
use std::path::{Path, PathBuf};
/// `path` as the project's roots spell it, `inside` telling whether a path is
/// under one. Roots are canonical, while a file can arrive under another
/// spelling (other letter case on macOS, a symlinked folder) and would look
/// outside the project, missing its frameworks' markers.
pub fn project_spelling<'a>(path: &'a Path, inside: impl Fn(&Path) -> bool) -> Cow<'a, Path> {
if inside(path) {
return path.into();
}
match dunce::canonicalize(path) {
Ok(canonical) if inside(&canonical) => canonical.into(),
_ => path.into(),
}
}
/// The outermost ancestor of `file` containing a root marker, within
/// `project_root` (any ancestor without one: loose files). A directory counts
/// as its own ancestor: a module folder is served like the files in it.
+35
Переглянути файл
@@ -90,6 +90,7 @@ const BUILTIN: &[(&str, &str)] = &[
("toml", include_str!("../../../languages/toml.toml")),
("typescript", include_str!("../../../languages/typescript.toml")),
("typescriptreact", include_str!("../../../languages/typescriptreact.toml")),
("typst", include_str!("../../../languages/typst.toml")),
("vue", include_str!("../../../languages/vue.toml")),
("xml", include_str!("../../../languages/xml.toml")),
("yaml", include_str!("../../../languages/yaml.toml")),
@@ -370,6 +371,7 @@ impl LanguageRegistry {
pub fn framework_ui_mode(&self, language: &LanguageId, path: &Path, project_root: Option<&Path>) -> Option<String> {
let state = self.state();
let cfg = state.languages.iter().find(|l| &l.id == language)?;
let path = &*crate::project_spelling(path, |p| project_root.is_none_or(|root| p.starts_with(root)));
cfg.framework_ui_modes
.iter()
.find(|f| crate::marked_root(project_root, path, &f.root_markers).is_some())
@@ -612,6 +614,7 @@ mod tests {
"TTCN",
"TTCN_CFG",
"Turtle",
"Typst",
"Web IDL",
"VB.NET",
"VBScript",
@@ -926,6 +929,38 @@ mod tests {
assert_eq!(detect("pages/promo.html"), "html");
}
/// #4061: the project root is canonical; a template reached under another
/// spelling of it is still the project's.
#[test]
fn templates_spelt_differently_from_the_project_use_framework_modes() {
let reg = reg();
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap().join("Develop/shop");
std::fs::create_dir_all(root.join("node_modules/@angular/core")).unwrap();
let template = root.join("apps/myapp/src/app/example.component.html");
std::fs::create_dir_all(template.parent().unwrap()).unwrap();
std::fs::write(&template, "<button (click)=\"onConfirm()\">Confirm</button>\n").unwrap();
let mode = |path: &Path| reg.framework_ui_mode(&LanguageId::new("html"), path, Some(&root));
let links = tempfile::tempdir().unwrap();
let mut spellings = Vec::new();
#[cfg(unix)]
{
std::os::unix::fs::symlink(&root, links.path().join("shop")).unwrap();
spellings.push(links.path().join("shop").join(template.strip_prefix(&root).unwrap()));
}
// Only on a case-insensitive disk (macOS, Windows): `develop` for `Develop`.
let lower = PathBuf::from(template.to_string_lossy().replace("Develop", "develop"));
if lower.exists() {
spellings.push(lower);
}
for path in &spellings {
assert_eq!(mode(path).as_deref(), Some("Angular Template"), "{}", path.display());
}
// Still nothing for files that are elsewhere under every spelling.
std::fs::create_dir_all(links.path().join("other")).unwrap();
assert_eq!(mode(&links.path().join("other/index.html")), None);
}
#[test]
fn markers_outside_the_project_do_not_make_angular_templates() {
let reg = reg();
+4 -3
Переглянути файл
@@ -6,8 +6,8 @@
//! parse instead of a full one.
use super::{
Grammar, MAX_PARSE_BYTES, ParsedTree, Syntax, SyntaxHighlights, TreeError, folding, highlight, outline,
parse_cancellable, selection,
Grammar, MAX_PARSE_BYTES, ParsedTree, Syntax, SyntaxHighlights, TreeError, highlight, outline, parse_cancellable,
selection,
};
use crate::FoldRange;
use ide_core::{DocId, LanguageId, OutlineItem, Range};
@@ -219,9 +219,10 @@ impl SyntaxCache {
|m| &mut m.folding,
|| {
self.with_tree(doc, lang, version, text, |g, tree, text| {
Some(folding::folding(g.spec, g.kinds(), tree, text, self.syntax.comment_tokens(lang)))
Some(self.syntax.folding_with_scripts(g, tree, text, lang))
})
.or_else(|| super::external::folding(lang, text))
.or_else(|| self.syntax.web_folding(lang, text))
.or_else(|| Some(self.syntax.custom_folding(lang, text)))
},
)
+68
Переглянути файл
@@ -118,6 +118,16 @@ pub(super) fn folding(
});
return true;
}
// Some languages write documentation as a string-like node rather than a
// lexical comment (Python docstrings, Elixir `@doc` / `@moduledoc`). The
// generic comment pass above never sees those, so fold them as documentation.
if node.is_named()
&& start != end
&& let Some(fold) = docstring_fold(spec, &node, kinds, text)
{
out.push(fold);
return false;
}
if start != end && !spec.imports.is_empty() && node.named_child_count() > 1 {
import_runs(kinds, node, text, &mut out);
}
@@ -206,6 +216,64 @@ pub(crate) fn is_comment(kind: &str) -> bool {
kind.contains("comment") || kind == "Comment"
}
/// Folds a documentation string written as a non-comment node. Returns `None`
/// for every other node; the caller skips its subtree only on a match.
fn docstring_fold(spec: &Spec, node: &Node, kinds: &KindTable, text: &str) -> Option<FoldRange> {
let multi_line = |n: &Node| n.start_position().row != n.end_position().row && kinds.has(n, FOLD_NODE);
let range = |n: &Node| FoldRange {
start_line: n.start_position().row as u32,
end_line: last_content_row(n, text) as u32,
kind: FoldKind::Comment,
};
match spec.name {
// A bare string as the first statement of a module/class/function body.
"python" if node.kind() == "expression_statement" => {
let string = node.named_child(0)?;
if string.kind() != "string" || !multi_line(&string) {
return None;
}
let parent = node.parent()?;
let mut cursor = parent.walk();
if parent.named_children(&mut cursor).find(|c| !kinds.has(c, COMMENT)) != Some(*node) {
return None;
}
Some(range(node))
}
// `@doc """…"""` / `@moduledoc """…"""`: an @-prefixed call whose
// argument is a multi-line string (or a sigil like `~S"""`).
"elixir" if node.kind() == "unary_operator" => {
let operand = node.child_by_field_name("operand")?;
if operand.kind() != "call" || !is_elixir_doc_attr(operand, text) {
return None;
}
// The string is the argument of the attribute call: `@doc """…"""`
// parses as unary_operator -> call(target: doc) -> arguments -> string.
let mut cursor = operand.walk();
let doc_string =
operand.named_children(&mut cursor).find(|c| c.kind() == "arguments").and_then(|args| {
let mut args_cursor = args.walk();
args.named_children(&mut args_cursor).find(|c| multi_line(c))
})?;
if !matches!(doc_string.kind(), "string" | "sigil") {
return None;
}
Some(range(&doc_string))
}
_ => None,
}
}
/// Whether an Elixir `call` is `@doc` / `@moduledoc` / `@typedoc` (the documented
/// attributes that take a string argument).
fn is_elixir_doc_attr(call: Node, text: &str) -> bool {
let Some(target) = call.child_by_field_name("target") else { return false };
let name = text.get(target.byte_range()).unwrap_or_default();
if target.kind() != "identifier" {
return false;
}
matches!(name, "doc" | "moduledoc" | "typedoc")
}
/// Row of the closing token when `node` is delimited by a matching bracket pair.
pub(crate) fn bracket_pair<'t>(node: &Node<'t>) -> Option<(Node<'t>, Node<'t>)> {
let count = node.child_count();
+29 -2
Переглянути файл
@@ -190,11 +190,38 @@ impl Syntax {
}
pub fn folding(&self, lang: &LanguageId, text: &str) -> Vec<FoldRange> {
let tokens = self.comment_tokens(lang);
self.analyze(lang, text, |g, tree, text| Some(folding::folding(g.spec, g.kinds(), tree, text, tokens)))
self.web_folding(lang, text)
.or_else(|| self.analyze(lang, text, |g, tree, text| Some(self.folding_with_scripts(g, tree, text, lang))))
.unwrap_or_else(|| self.custom_folding(lang, text))
}
pub(crate) fn web_folding(&self, lang: &LanguageId, text: &str) -> Option<Vec<FoldRange>> {
let g = self.web_grammar(lang)?;
if g.spec.name != "html" || text.len() > MAX_PARSE_BYTES {
return None;
}
let tree = parse(&g.language, text, None)?;
Some(self.folding_with_scripts(g, &tree, text, lang))
}
fn folding_with_scripts(&self, g: &Grammar, tree: &Tree, text: &str, lang: &LanguageId) -> Vec<FoldRange> {
let mut folds = folding::folding(g.spec, g.kinds(), tree, text, self.comment_tokens(lang));
if g.spec.name == "html" {
let lines = lines::LineIndex::new(text);
for region in sfc::script_regions(tree, text) {
let base_line = lines.line_of(region.base) as u32;
folds.extend(self.folding(&region.language, &region.text).into_iter().map(|mut fold| {
fold.start_line += base_line;
fold.end_line += base_line;
fold
}));
}
folds.sort_by(|a, b| a.start_line.cmp(&b.start_line).then(b.end_line.cmp(&a.end_line)));
folds.dedup_by_key(|f| f.start_line);
}
folds
}
fn comment_tokens(&self, lang: &LanguageId) -> &folding::CommentTokens {
static EMPTY: OnceLock<folding::CommentTokens> = OnceLock::new();
self.comments.get(lang.as_str()).unwrap_or_else(|| EMPTY.get_or_init(Default::default))
+93
Переглянути файл
@@ -987,6 +987,28 @@ fn folding_typescript_import_run_ending_with_multiline_import() {
assert!(folds("typescript", src).contains(&(0, 4, FoldKind::Imports)));
}
#[test]
fn folding_script_imports_in_web_containers() {
use ide_core::DocId;
use std::sync::Arc;
let src = "<template><div/></template>\n<script setup lang=\"ts\">\nimport { ref, normalizeStyle } from 'vue'\nimport { Button, CheckableTagGroup, Divider, Space } from 'antdv-next'\n</script>\n";
let cache = SyntaxCache::new(Arc::new(Syntax::new()));
for id in ["vue", "html", "svelte", "jsp"] {
let expected = (2, 3, FoldKind::Imports);
assert!(folds(id, src).contains(&expected), "{id}");
let doc = DocId::next();
cache.open(doc, &lang(id), 0);
let cached = cache.folding(doc, &lang(id), 0, src);
assert!(cached.iter().any(|f| (f.start_line, f.end_line, f.kind) == expected), "{id}");
}
let js = "<script>\r\nimport a from 'a'\r\nimport b from 'b'\r\n</script>\r\n";
assert!(folds("vue", js).contains(&(1, 2, FoldKind::Imports)));
let json = "<script type=\"application/json\">\nimport a from 'a'\nimport b from 'b'\n</script>\n";
assert!(!folds("vue", json).iter().any(|f| f.2 == FoldKind::Imports));
}
#[test]
fn folding_xml_custom_regions() {
for (start, end) in [
@@ -1081,6 +1103,77 @@ fn folding_python_bodies_start_at_header() {
);
}
#[test]
fn folding_python_docstrings_are_comments() {
let src = r#""""Module doc.
More.
"""
class A:
"""Class doc.
More.
"""
def f(self):
"""Method doc.
More.
"""
return 1
"#;
assert_eq!(
folds("python", src),
vec![
(0, 2, FoldKind::Comment),
(4, 12, FoldKind::Region),
(5, 7, FoldKind::Comment),
(8, 12, FoldKind::Region),
(9, 11, FoldKind::Comment),
]
);
}
#[test]
fn folding_python_single_line_or_later_strings_are_not_docstrings() {
// A one-line docstring has nothing to fold; a multi-line string that is not
// the opening statement stays an ordinary string fold, not a doc comment.
let src = r#"x = 1
"""Later string.
Still later.
"""
def f():
"""One line."""
return 1
"#;
let found = folds("python", src);
assert!(!found.contains(&(1, 3, FoldKind::Comment)), "later string must not be a doc comment: {found:?}");
assert!(found.contains(&(1, 3, FoldKind::Region)), "later string still folds as a string: {found:?}");
assert!(!found.iter().any(|f| f.2 == FoldKind::Comment), "single-line docstring has no fold: {found:?}");
}
#[test]
fn folding_elixir_doc_strings_are_comments() {
let src = r#"defmodule Foo do
@moduledoc """
Module doc.
More.
"""
@doc ~S"""
Function doc.
More.
"""
def bar, do: :ok
@doc "one line"
def baz, do: :ok
end
"#;
assert_eq!(
folds("elixir", src),
vec![(0, 14, FoldKind::Region), (1, 4, FoldKind::Comment), (6, 9, FoldKind::Comment),]
);
}
#[test]
fn folding_data_and_markup() {
assert_eq!(
+2
Переглянути файл
@@ -1032,6 +1032,7 @@ pub fn call_item(conv: &Conv, item: &lsp::CallHierarchyItem, from_ranges: Vec<Ra
path: path.into(),
uri,
from_ranges,
from_path: None,
})
}
@@ -1056,6 +1057,7 @@ pub fn type_item(conv: &Conv, item: &lsp::TypeHierarchyItem) -> Option<Hierarchy
path: path.into(),
uri,
from_ranges: Vec::new(),
from_path: None,
})
}
+47 -6
Переглянути файл
@@ -7,6 +7,7 @@
use crate::LspManager;
use crate::server::Server;
use ide_core::{CancellationToken, DocId, Pos, Range};
use ide_language::LanguageServerConfig;
use serde::Deserialize;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
@@ -125,10 +126,10 @@ impl LspManager {
return;
}
let config = server.effective_config();
let search = crate::launch::server_search_path(&config);
let search = crate::launch::server_search_path(&config, &server.root);
let Some(dir) = path.parent().map(Path::to_path_buf) else { return };
let modules: Vec<String> = required.iter().map(|r| r.path.clone()).collect();
let Some(deprecated) = list_deprecations(&dir, &search, &modules, cancel).await else { return };
let Some(deprecated) = list_deprecations(&dir, &config, &search, &modules, cancel).await else { return };
// The document changed meanwhile: its own save runs again.
if cancel.is_cancelled() || self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
return;
@@ -208,16 +209,15 @@ struct ListedModule {
/// `(module, message)` of each deprecated module in `modules`; `None` when `go` failed.
async fn list_deprecations(
dir: &Path,
config: &LanguageServerConfig,
search: &std::ffi::OsStr,
modules: &[String],
cancel: &CancellationToken,
) -> Option<Vec<(String, String)>> {
let (dir, search, modules) = (dir.to_path_buf(), search.to_owned(), modules.to_vec());
let (dir, config, search, modules) = (dir.to_path_buf(), config.clone(), search.to_owned(), modules.to_vec());
let command = tokio::task::spawn_blocking(move || {
let go: PathBuf = ide_core::tool_path::find_command("go", &search, &dir)?;
let mut command = Command::new(go);
command.args(["list", "-m", "-u", "-e", "-json"]).args(modules).current_dir(dir).env("PATH", search);
Some(command)
Some(deprecations_command(&go, &dir, &config, &search, &modules))
})
.await
.ok()??;
@@ -228,6 +228,23 @@ async fn list_deprecations(
tokio::task::spawn_blocking(move || parse_deprecations(&output)).await.ok()
}
fn deprecations_command(
go: &Path,
dir: &Path,
config: &LanguageServerConfig,
search: &std::ffi::OsStr,
modules: &[String],
) -> Command {
let mut command = Command::new(go);
command
.args(["list", "-m", "-u", "-e", "-json"])
.args(modules)
.current_dir(dir)
.envs(&config.env)
.env("PATH", search);
command
}
async fn run_query(command: Command, cancel: &CancellationToken, timeout: Duration) -> Option<Vec<u8>> {
let cancel = cancel.child_token();
let _cancel_on_drop = cancel.clone().drop_guard();
@@ -314,6 +331,30 @@ fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
mod tests {
use super::*;
#[test]
fn deprecation_command_inherits_server_environment() {
let config: LanguageServerConfig = serde_json::from_value(serde_json::json!({
"name": "gopls", "command": "gopls", "env": {
"PATH": "selected-toolchain", "GOPROXY": "off", "GOPRIVATE": "example.invalid/*",
"GOTOOLCHAIN": "local", "GOWORK": "off"
}
}))
.unwrap();
let command = deprecations_command(
Path::new("go"),
Path::new("workspace"),
&config,
&crate::launch::server_search_path(&config, Path::new("workspace")),
&["example.invalid/lib".into()],
);
let env: std::collections::BTreeMap<_, _> = command.get_envs().collect();
for (key, value) in &config.env {
assert_eq!(env.get(std::ffi::OsStr::new(key)), Some(&Some(std::ffi::OsStr::new(value))), "missing {key}");
}
assert_eq!(command.get_current_dir(), Some(Path::new("workspace")));
assert_eq!(command.get_args().collect::<Vec<_>>(), ["list", "-m", "-u", "-e", "-json", "example.invalid/lib"]);
}
#[test]
fn queries_cancel_only_the_superseded_document() {
let mut queries = Queries::default();
+5 -5
Переглянути файл
@@ -527,7 +527,7 @@ impl Handler for ClientHandler {
"window/logMessage" => {
let text = params.get("message").and_then(Value::as_str).unwrap_or_default();
if self.server.config.tsserver_project && tsserver_ran_out_of_memory(text) {
tracing::warn!("[{}] {text}", self.server.name);
tracing::warn!(server = ?self.server.id, generation = self.generation, "[{}] {text}", self.server.name);
// The tasks of the dead tsserver never see their `end`: end them now
// instead of letting them sit as zombies until the stale window, and
// stop holding queries back — the restarted instance re-reports.
@@ -554,12 +554,12 @@ impl Handler for ClientHandler {
}
match params.get("type").and_then(Value::as_u64) {
Some(1) if self.server.name == "jdtls" && text.contains(crate::jdtls::reserved_names::IMPORT_FAILURE) => {
tracing::warn!("[{}] {text}", self.server.name);
tracing::warn!(server = ?self.server.id, generation = self.generation, "[{}] {text}", self.server.name);
mgr.report_import_failure(self.server.root.clone(), text.to_owned());
}
Some(1) => tracing::warn!("[{}] {text}", self.server.name),
Some(2 | 3) => tracing::info!("[{}] {text}", self.server.name),
_ => tracing::debug!("[{}] {text}", self.server.name),
Some(1) => tracing::warn!(server = ?self.server.id, generation = self.generation, "[{}] {text}", self.server.name),
Some(2 | 3) => tracing::info!(server = ?self.server.id, generation = self.generation, "[{}] {text}", self.server.name),
_ => tracing::debug!(server = ?self.server.id, generation = self.generation, "[{}] {text}", self.server.name),
}
}
"tsserver/request" => mgr.forward_tsserver_requests(self.server.clone(), self.generation, params),
+1
Переглянути файл
@@ -88,6 +88,7 @@ impl LspManager {
/// for `path` (by file name). Missing servers are not started, so a batch
/// run doesn't prompt to install every language it meets.
pub fn serves_path(&self, path: &Path) -> bool {
let path = &*self.in_project_spelling(path);
let lang = self.languages.detect(path, None);
let arduino = if lang.as_str() == "arduino" {
Some(self.servers_for(&lang, path))
+43 -15
Переглянути файл
@@ -1,7 +1,7 @@
//! Starting server processes: binary resolution and the [`Launcher`] seam.
use ide_core::CancellationToken;
use ide_core::tool_path::search_path;
use ide_core::tool_path::search_path_in;
use ide_jsonrpc::{Handler, Peer};
use ide_language::LanguageServerConfig;
use std::ffi::{OsStr, OsString};
@@ -95,10 +95,10 @@ impl Launcher for ProcessLauncher {
on_stderr: Box<dyn Fn(String) + Send + Sync>,
cancel: &CancellationToken,
) -> Result<(Peer, Option<PathBuf>), LaunchError> {
if !required_env_set(config) {
if !required_env_set(config, root) {
return Err(LaunchError::Missing);
}
let search = server_search_path(config);
let search = server_search_path(config, root);
let binary = match &config.pinned {
// A plugin's server: the approved program, unchanged since.
Some(pin) => Some(pin.verify().map_err(LaunchError::Failed)?.to_path_buf()),
@@ -128,26 +128,27 @@ impl Launcher for ProcessLauncher {
}
fn available(&self, config: &LanguageServerConfig, root: &Path) -> bool {
if !required_env_set(config) {
if !required_env_set(config, root) {
return false;
}
if let Some(pin) = &config.pinned {
return pin.path.is_file();
}
ide_core::tool_path::find_command(&config.command, &server_search_path(config), root).is_some()
ide_core::tool_path::find_command(&config.command, &server_search_path(config, root), root).is_some()
}
}
fn required_env_set(config: &LanguageServerConfig) -> bool {
fn required_env_set(config: &LanguageServerConfig, root: &Path) -> bool {
config.requires_env.iter().all(|key| match config.env.get(key) {
Some(value) => !value.is_empty(),
None => ide_core::process::host_var_os(key).is_some_and(|v| !v.is_empty()),
None => ide_core::process::host_var_os_in(root, key).is_some_and(|v| !v.is_empty()),
})
}
/// A configured `PATH` (e.g. a selected toolchain prepended) also resolves the binary.
pub(crate) fn server_search_path(config: &LanguageServerConfig) -> OsString {
config.env.get("PATH").map(OsString::from).unwrap_or_else(search_path)
/// A configured `PATH` (e.g. a selected toolchain prepended) also resolves the binary; else
/// the project's (a Nix devshell's language servers), then the IDE's.
pub(crate) fn server_search_path(config: &LanguageServerConfig, root: &Path) -> OsString {
config.env.get("PATH").map(OsString::from).unwrap_or_else(|| search_path_in(root))
}
/// What a version manager's shim says when the active version has no such tool.
@@ -162,9 +163,8 @@ fn reject_dead_shim(binary: PathBuf, search: &OsStr, root: &Path) -> Option<Path
if !binary.parent().is_some_and(|d| d.file_name().is_some_and(|n| n == "shims")) {
return Some(binary);
}
let Ok(mut child) = ide_core::process::prepare(&mut std::process::Command::new(&binary))
let Ok(mut child) = ide_core::process::prepare(std::process::Command::new(&binary).current_dir(root))
.arg("--version")
.current_dir(root)
.env("PATH", search)
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
@@ -235,9 +235,8 @@ fn resolve_rustup_proxy(command: &str, binary: PathBuf, root: &Path) -> Option<P
/// Whether the proxy runs for the toolchain active in `root`. A probe that hangs or can't
/// be waited for counts as working: the real start decides.
fn proxy_works(binary: &Path, root: &Path) -> bool {
let Ok(mut child) = ide_core::process::prepare(&mut std::process::Command::new(binary))
let Ok(mut child) = ide_core::process::prepare(std::process::Command::new(binary).current_dir(root))
.arg("--version")
.current_dir(root)
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
@@ -348,6 +347,35 @@ mod tests {
assert_eq!(reject_dead_shim(plain.clone(), &search, tmp.path()), Some(plain));
}
#[cfg(unix)]
#[test]
fn servers_from_the_project_environment_are_found() {
use std::os::unix::fs::PermissionsExt;
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("project");
let devshell = tmp.path().join("nix-store-devshell/bin");
std::fs::create_dir_all(&devshell).unwrap();
std::fs::create_dir_all(&root).unwrap();
let server = devshell.join("openidea-test-nil");
std::fs::write(&server, "#!/bin/sh\n").unwrap();
std::fs::set_permissions(&server, std::fs::Permissions::from_mode(0o755)).unwrap();
let mut config: LanguageServerConfig =
toml::from_str("name = \"nil\"\ncommand = \"openidea-test-nil\"").unwrap();
config.requires_env = vec!["OPENIDEA_TEST_IN_DEVSHELL".into()];
assert!(!ProcessLauncher.available(&config, &root));
ide_core::project_env::set(
&root,
vec![
("PATH".into(), Some(devshell.clone().into_os_string())),
("OPENIDEA_TEST_IN_DEVSHELL".into(), Some("1".into())),
],
);
assert!(ProcessLauncher.available(&config, &root));
assert_eq!(std::env::split_paths(&server_search_path(&config, &root)).next(), Some(devshell));
ide_core::project_env::remove(&root);
assert!(!ProcessLauncher.available(&config, &root));
}
#[test]
fn marked_root_needs_a_marker() {
let tmp = tempfile::tempdir().unwrap();
@@ -381,7 +409,7 @@ mod tests {
#[test]
fn search_path_contains_env_path() {
let p = search_path();
let p = ide_core::tool_path::search_path();
let dirs: Vec<PathBuf> = std::env::split_paths(&p).collect();
// The process's own `PATH` starts the search, then per-user and system dirs.
let first_env = std::env::split_paths(&std::env::var_os("PATH").unwrap()).find(|d| d.is_absolute()).unwrap();
+103 -4
Переглянути файл
@@ -649,6 +649,11 @@ impl LspManager {
.unwrap_or_else(|| self.project_root.clone())
}
/// `path` as the project's roots spell it ([`ide_language::project_spelling`]).
fn in_project_spelling<'a>(&self, path: &'a Path) -> std::borrow::Cow<'a, Path> {
ide_language::project_spelling(path, |p| p.starts_with(self.project_root_for(p)))
}
fn server_for(&self, cfg: &LanguageServerConfig, language: &LanguageId, path: &Path) -> Arc<Server> {
let shared = is_local_jdtls(cfg).then(|| self.jdtls_workspace_state());
let mut servers = self.servers.lock();
@@ -670,10 +675,25 @@ impl LspManager {
})
};
if let Some(s) = servers.iter().find(|s| s.name == cfg.name && s.root == root) {
if !path.starts_with(&project) {
tracing::debug!(
server = ?s.id,
name = %s.name,
root = %s.root.display(),
"reusing language server for external file"
);
}
s.add_language(language);
return s.clone();
}
let server = Arc::new(Server::new(cfg.clone(), root, language.clone()));
tracing::debug!(
server = ?server.id,
name = %server.name,
root = %server.root.display(),
external = !path.starts_with(&project),
"created language server route"
);
servers.push(server.clone());
server
}
@@ -684,6 +704,7 @@ impl LspManager {
/// only files below one, and stands in for no other. One that a server before
/// it `replaces` is left out while that server serves the file.
fn servers_for(&self, language: &LanguageId, path: &Path) -> Vec<Arc<Server>> {
let path = &*self.in_project_spelling(path);
if let Some(servers) = self.arduino_servers(language, path) {
return servers;
}
@@ -828,6 +849,9 @@ impl LspManager {
async fn run_instance(self: Arc<Self>, server: Arc<Server>, generation: u64) {
let Some(cancel) = server.starting_status(generation, &self.sink) else { return };
// Includes settings/prepare, blocking-pool queueing, launch and initialize.
let started = std::time::Instant::now();
tracing::info!(server = ?server.id, generation, name = %server.name, "starting language server");
let handler = Arc::new(handler::ClientHandler::new(self.me.clone(), server.clone(), generation));
let me = self.clone();
let tail = server.clone();
@@ -835,6 +859,9 @@ impl LspManager {
// The settings hook may touch the filesystem (e.g. scanning for JDKs); TCP
// servers may take a while to start listening.
let launched = tokio::task::spawn_blocking(move || {
// The project's direnv environment (a Nix devshell) may hold the server and its
// toolchain: start once it has loaded.
ide_core::project_env::wait(&tail.root, &launch_cancel);
if !me.execution_allowed.load(Ordering::Acquire) {
return Err(LaunchError::Config("Project is in Restricted Mode".into()));
}
@@ -946,8 +973,15 @@ impl LspManager {
};
let caps = match result {
Ok(result) => {
tracing::info!(
server = ?server.id,
generation,
name = %server.name,
startup_to_initialize_ms = started.elapsed().as_millis() as u64,
"language server initialized"
);
if let Some(info) = result.get("serverInfo") {
tracing::info!("{} initialized: {info}", server.name);
tracing::info!(server = ?server.id, generation, "{} initialized: {info}", server.name);
}
let mut caps_val = result.get("capabilities").cloned().unwrap_or_else(|| json!({}));
if server.name == arduino::SERVER {
@@ -3241,6 +3275,7 @@ impl LspManager {
.call(t, "textDocument/prepareCallHierarchy", snap.pos_params(t, pos), Some(cancel), DEFAULT_TIMEOUT)
.await?;
let items = items.filter(|i| !i.is_empty()).ok_or_else(no_hierarchy_target)?;
let root = convert::call_item(&self.conv(t.enc()), &items[0], Vec::new());
let query = || async {
let mut out = Vec::new();
for item in &items {
@@ -3263,7 +3298,10 @@ impl LspManager {
let (src, _) = uri_target(item.uri.as_str());
for c in calls.unwrap_or_default() {
let ranges = c.from_ranges.iter().map(|r| conv.range(&src, *r)).collect();
out.extend(convert::call_item(&conv, &c.to, ranges));
out.extend(
convert::call_item(&conv, &c.to, ranges)
.map(|to| HierarchyItem { from_path: Some(src.clone().into()), ..to }),
);
}
}
}
@@ -3293,8 +3331,8 @@ impl LspManager {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
self.note_virtual(&t.server, out.iter().map(|i| i.uri.as_deref()));
Ok(CallHierarchy { items: out, incomplete })
self.note_virtual(&t.server, out.iter().chain(&root).map(|i| i.uri.as_deref()));
Ok(CallHierarchy { root, items: out, incomplete })
}
/// The type at `pos` as the server's type hierarchy names it (with its `detail`, the
@@ -4264,3 +4302,64 @@ mod code_action_tests {
assert!(!source_actions_only(&kinds(&["sourcefoo"])));
}
}
#[cfg(test)]
mod external_go_routing_tests {
use super::*;
fn manager(root: &Path) -> Arc<LspManager> {
LspManager::new(
root.to_owned(),
Arc::new(LanguageRegistry::load(None).unwrap()),
Arc::new(|_: ide_core::IdeEvent| {}),
)
}
fn route(manager: &LspManager, path: &Path) -> Arc<Server> {
let language = LanguageId::new("go");
let config = manager.languages.get(&language).unwrap();
manager.server_for(&config.language_servers[0], &language, path)
}
fn module(root: &Path, name: &str) -> PathBuf {
let root = root.join(name);
std::fs::create_dir_all(&root).unwrap();
std::fs::write(root.join("go.mod"), format!("module example.test/{name}\n")).unwrap();
root.join("main.go")
}
// Characterize the fallback, not a promise that this is the correct consumer
// context for a shared dependency. No gopls process is launched in these tests.
#[tokio::test]
async fn external_go_file_reuses_first_module_without_creating_another_server() {
let workspace = tempfile::tempdir().unwrap();
let cache = tempfile::tempdir().unwrap();
let a = module(workspace.path(), "a");
let b = module(workspace.path(), "b");
let dependency = cache.path().join("dependency.go");
for order in [[&a, &b], [&b, &a]] {
let manager = manager(workspace.path());
let first = route(&manager, order[0]);
let second = route(&manager, order[1]);
assert_ne!(first.id, second.id);
assert_eq!(route(&manager, &dependency).id, first.id);
assert_eq!(route(&manager, &dependency).id, first.id);
assert_eq!(manager.servers.lock().len(), 2);
}
}
#[tokio::test]
async fn external_go_file_restored_first_keeps_project_root_fallback() {
let workspace = tempfile::tempdir().unwrap();
let cache = tempfile::tempdir().unwrap();
let a = module(workspace.path(), "a");
let dependency = cache.path().join("dependency.go");
let manager = manager(workspace.path());
let restored = route(&manager, &dependency);
assert_eq!(restored.root, workspace.path());
let consumer = route(&manager, &a);
assert_ne!(restored.id, consumer.id);
assert_eq!(route(&manager, &dependency).id, restored.id);
assert_eq!(manager.servers.lock().len(), 2);
}
}
+1
Переглянути файл
@@ -397,6 +397,7 @@ impl LspManager {
range: *r,
selection_range: *selection,
from_ranges: vec![*call],
from_path: None,
}),
}
}
+1 -1
Переглянути файл
@@ -94,9 +94,9 @@ pub(crate) fn connect_or_start(
let args = substitute_args(&config.args, port, root);
let mut cmd = tokio::process::Command::new(binary);
cmd.current_dir(root);
ide_core::process::prepare(cmd.as_std_mut());
cmd.args(&args)
.current_dir(root)
.envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())))
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::piped())
+9
Переглянути файл
@@ -329,6 +329,11 @@ pub struct HierarchyItem {
pub selection_range: Range,
/// Call sites, for call hierarchy.
pub from_ranges: Vec<Range>,
/// The file of `from_ranges` when it is not the item's own: for an outgoing call, the
/// file of the prepared item that makes it (a path, or the URI of a virtual document).
#[serde(default)]
#[specta(optional)]
pub from_path: Option<ide_core::IpcPath>,
}
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
@@ -575,6 +580,10 @@ pub struct ServerRefactored {
#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct CallHierarchy {
/// The symbol the hierarchy is for: the first item the server prepared at the position.
#[serde(default)]
#[specta(optional)]
pub root: Option<HierarchyItem>,
pub items: Vec<HierarchyItem>,
pub incomplete: Option<ReferencesIncomplete>,
}
+126 -10
Переглянути файл
@@ -23,6 +23,7 @@ use std::time::Duration;
struct MockState {
caps: Mutex<Value>,
missing: std::sync::atomic::AtomicBool,
omit_server_info: std::sync::atomic::AtomicBool,
binary: Mutex<Option<PathBuf>>,
launches: AtomicUsize,
notifications: Mutex<Vec<(String, Value)>>,
@@ -149,7 +150,11 @@ impl Handler for MockHandler {
if let Some(error) = s.errors.lock().get("initialize").cloned() {
return Err(error);
}
Ok(json!({ "capabilities": s.caps.lock().clone(), "serverInfo": { "name": "mock" } }))
let mut result = json!({ "capabilities": s.caps.lock().clone() });
if !s.omit_server_info.load(Ordering::SeqCst) {
result["serverInfo"] = json!({ "name": "mock" });
}
Ok(result)
}
"shutdown" => Ok(Value::Null),
_ => {
@@ -478,6 +483,23 @@ async fn dart_file_watching_requires_an_explicit_registration() {
// ------------------------------------------------------------------ tests
#[tokio::test(flavor = "multi_thread")]
async fn servers_start_once_the_project_environment_has_loaded() {
let h = harness(&[("mock", incremental_caps())]);
// The project's direnv environment (a Nix devshell) is still being read.
ide_core::project_env::begin_loading(&h.root);
h.open("a.mk", "x");
h.wait_status("mock", ServerStatus::Starting).await;
tokio::time::sleep(Duration::from_millis(300)).await;
let server = h.launcher.state("mock");
assert_eq!(server.launches.load(Ordering::SeqCst), 0);
ide_core::project_env::set(&h.root, vec![("OPENIDEA_TEST_DEVSHELL".into(), Some("1".into()))]);
h.wait_status("mock", ServerStatus::Ready).await;
assert_eq!(server.launches.load(Ordering::SeqCst), 1);
ide_core::project_env::remove(&h.root);
h.mgr.shutdown_all().await;
}
#[tokio::test(flavor = "multi_thread")]
async fn linked_projects_initialize_separate_language_server_roots() {
let h = harness(&[("mock", incremental_caps())]);
@@ -2983,13 +3005,13 @@ async fn a_project_update_attaches_maven_generated_sources_before_rechecking() {
.as_array()
.unwrap()
.iter()
.map(|arg| (arg["path"].as_str().unwrap().to_owned(), arg["test"].as_bool().unwrap()))
.map(|arg| (PathBuf::from(arg["path"].as_str().unwrap()), arg["test"].as_bool().unwrap()))
.collect();
assert_eq!(
paths,
vec![
(h.root.join("target/generated-sources/protobuf/grpc-java").to_string_lossy().into_owned(), false),
(h.root.join("target/generated-sources/protobuf/java").to_string_lossy().into_owned(), false),
(h.root.join("target/generated-sources/protobuf/grpc-java"), false),
(h.root.join("target/generated-sources/protobuf/java"), false),
]
);
}
@@ -3611,6 +3633,52 @@ async fn a_server_requiring_a_root_marker_serves_only_files_below_one() {
h.wait_status("alt", ServerStatus::Ready).await;
}
/// #4061: an Angular template opened under another spelling of the project's
/// (canonical) path, other letter case on macOS or a symlinked folder, still
/// gets the Angular server, which answers hover and Go to Declaration there.
#[tokio::test(flavor = "multi_thread")]
async fn a_framework_server_serves_files_spelt_differently_from_the_project() {
let h = harness_configured("mock", "html", &[("framework", incremental_caps())], |cfg| {
cfg.root_markers = vec!["angular.json".into()];
cfg.require_root_marker = true;
});
std::fs::write(h.root.join("angular.json"), "{}").unwrap();
let app = h.root.join("apps/myapp/src/app");
std::fs::create_dir_all(&app).unwrap();
let (template, component) = (app.join("example.component.html"), app.join("example.component.ts"));
std::fs::write(&template, "<button (click)=\"onConfirm()\">Confirm</button>\n").unwrap();
std::fs::write(&component, "export class ExampleComponent {\n onConfirm() {}\n}\n").unwrap();
let framework = h.launcher.state("framework");
framework.respond("textDocument/hover", json!({ "contents": "(method) ExampleComponent.onConfirm(): void" }));
let target = Range::new(Pos::new(1, 2), Pos::new(1, 11));
let range = json!({ "start": { "line": 1, "character": 2 }, "end": { "line": 1, "character": 11 } });
framework.respond("textDocument/definition", json!([{ "uri": uri_of(&component), "range": range }]));
#[cfg(unix)]
let links = tempfile::tempdir().unwrap();
let mut spellings = Vec::new();
#[cfg(unix)]
{
std::os::unix::fs::symlink(&h.root, links.path().join("linked")).unwrap();
spellings.push(links.path().join("linked").join(template.strip_prefix(&h.root).unwrap()));
}
// Only on a case-insensitive disk (macOS, Windows).
let upper = PathBuf::from(template.to_string_lossy().to_uppercase());
if upper.exists() {
spellings.push(upper);
}
for path in spellings {
let doc = DocId::next();
h.mgr.did_open(doc, &path, &h.lang, 1, "<button (click)=\"onConfirm()\">Confirm</button>\n");
eventually(|| framework.docs.lock().contains_key(&uri_of(&path))).await;
let hover = h.mgr.hover(doc, Pos::new(0, 20), Default::default()).await.unwrap();
assert!(hover.is_some_and(|h| h.contents.value.contains("onConfirm")), "{}", path.display());
let defs = h.mgr.goto(doc, Pos::new(0, 20), GotoKind::Definition).await.unwrap();
assert_eq!((&*defs[0].path, defs[0].range), (component.as_path(), target), "{}", path.display());
}
assert_eq!(h.statuses("framework").iter().filter(|s| **s == ServerStatus::Starting).count(), 1);
}
/// A server that `replaces` another (a PHP server with its own Laravel support and
/// `laravel-lsp`) keeps it away while it serves, and only then.
#[tokio::test(flavor = "multi_thread")]
@@ -3934,17 +4002,32 @@ async fn navigation_rename_format_and_decorations() {
let item = json!({ "name": "foo", "kind": 12, "uri": uri, "range": r(0,0,0,11), "selectionRange": r(0,3,0,6), "data": "id" });
s.respond("textDocument/prepareCallHierarchy", json!([item]));
s.respond("callHierarchy/incomingCalls", json!([{ "from": { "name": "main", "kind": 12, "uri": uri, "range": r(1,0,1,6), "selectionRange": r(1,0,1,3) }, "fromRanges": [r(1,0,1,3)] }]));
let calls = h
.mgr
.call_hierarchy(doc, Pos::new(0, 4), HierarchyDirection::Incoming, Default::default())
.await
.unwrap()
.items;
let hierarchy =
h.mgr.call_hierarchy(doc, Pos::new(0, 4), HierarchyDirection::Incoming, Default::default()).await.unwrap();
let root = hierarchy.root.expect("the prepared item");
assert_eq!((root.name.as_str(), root.selection_range), ("foo", rng(0, 3, 0, 6)));
assert_eq!(root.path.to_path_buf(), path);
let calls = hierarchy.items;
assert_eq!(calls.len(), 1);
assert_eq!(calls[0].name, "main");
assert_eq!(calls[0].from_ranges, vec![rng(1, 0, 1, 3)]);
assert_eq!(s.requested("callHierarchy/incomingCalls")[0]["item"]["data"], "id");
// Outgoing calls of each prepared item are in that item's file.
let other = path.with_file_name("b.mk");
let second =
json!({ "name": "foo", "kind": 12, "uri": uri_of(&other), "range": r(4,0,4,11), "selectionRange": r(4,3,4,6) });
s.respond("textDocument/prepareCallHierarchy", json!([item, second]));
s.respond("callHierarchy/outgoingCalls", json!([{ "to": { "name": "bar", "kind": 12, "uri": uri, "range": r(2,0,2,6), "selectionRange": r(2,0,2,3) }, "fromRanges": [r(0,8,0,11)] }]));
let callees = h
.mgr
.call_hierarchy(doc, Pos::new(0, 4), HierarchyDirection::Outgoing, Default::default())
.await
.unwrap()
.items;
let from: Vec<_> = callees.iter().map(|c| c.from_path.clone().map(|p| p.into_path_buf())).collect();
assert_eq!(from, [Some(path.clone()), Some(other)]);
// No documentSymbolProvider → None so callers fall back to tree-sitter.
assert_eq!(h.mgr.document_symbols(doc).await.unwrap(), None);
}
@@ -7743,6 +7826,39 @@ async fn notebook_edits_change_cell_text_and_reorders_reopen_it() {
h.mgr.shutdown_all().await;
}
#[tokio::test(flavor = "multi_thread")]
async fn external_go_file_reuses_module_and_reopens_after_restart() {
let h = harness_configured("go", "go", &[("gopls", incremental_caps())], |cfg| {
cfg.root_markers = vec!["go.work".into(), "go.mod".into()];
});
h.launcher.state("gopls").omit_server_info.store(true, Ordering::SeqCst);
let module = h.root.join("service");
std::fs::create_dir_all(&module).unwrap();
std::fs::write(module.join("go.mod"), "module example.test/service\n").unwrap();
h.open("service/main.go", "package service\n");
h.wait_status("gopls", ServerStatus::Ready).await;
let cache = tempfile::tempdir().unwrap();
let external = cache.path().join("dependency.go");
std::fs::write(&external, "package dependency\n").unwrap();
let doc = DocId::next();
h.mgr.did_open(doc, &external, &h.lang, 1, "package dependency\n");
let state = h.launcher.state("gopls");
let opened_external = || {
state.notified("textDocument/didOpen").iter().filter(|p| p["textDocument"]["uri"] == uri_of(&external)).count()
};
eventually(|| opened_external() == 1).await;
assert_eq!(state.launches.load(Ordering::SeqCst), 1);
let id = h.mgr.servers()[0].id;
h.mgr.restart(id).await.unwrap();
eventually(|| opened_external() == 2).await;
assert_eq!(state.launches.load(Ordering::SeqCst), 2);
assert_eq!(h.mgr.servers().len(), 1);
let inits = state.requested("initialize");
assert_eq!(inits.len(), 2);
assert!(inits.iter().all(|p| p["rootUri"] == uri_of(&module)));
h.mgr.shutdown_all().await;
}
/// A plugin's request (`language-servers` in the plugin API) reaches the running server
/// named in the language definition: only the server's own methods, and never a start.
#[tokio::test(flavor = "multi_thread")]
+2 -2
Переглянути файл
@@ -17,8 +17,8 @@ mod wit_host;
pub use actor::{Actor, ActorError, Pending};
pub use runtime::{
API_VERSION, CANCELLED, CallCancel, CallError, GuestError, HostApi, PluginEngine, Runtime, RuntimeSetup, check_api,
component_api, host_api,
API_VERSION, CANCELLED, CallCancel, CallError, GuestError, HostApi, MAX_CLIPBOARD_BYTES, PluginEngine, Runtime,
RuntimeSetup, check_api, component_api, host_api,
};
pub use sandbox::{
MAX_READ_BYTES, inside_root, inside_roots, read_text, resolve_in_root, resolve_in_roots, resolve_new_in_root,
+17 -7
Переглянути файл
@@ -56,9 +56,11 @@ use views_bindings::exports::openidea::plugin::view_provider as wit_view;
use views_bindings::openidea::plugin::view_types as wit_vt;
/// The API version of the world above, `major.minor` of [`host_api`].
pub const API_VERSION: &str = "1.10";
pub const API_VERSION: &str = "1.11";
const EPOCH_TICK: Duration = Duration::from_millis(10);
pub(crate) const MAX_TEXT: usize = 1 << 20;
/// The most text, and the most PNG bytes, `ui.read-clipboard` returns.
pub const MAX_CLIPBOARD_BYTES: usize = 16 << 20;
pub(crate) const MAX_TITLE: usize = 256;
const STDERR_CAPACITY: usize = 256 << 10;
/// Message of a call interrupted through [`Runtime::cancel_handle`].
@@ -318,6 +320,12 @@ pub trait HostApi: Send + Sync {
let _ = (client, text);
Ok(())
}
/// The clipboard of the machine `client`'s window runs on, as that window reads it;
/// waits for the window until `cancel` fires.
fn read_clipboard(&self, client: &str, cancel: &CancellationToken) -> Result<crate::ClipboardContent, HostError> {
let _ = (client, cancel);
Err(HostError::Failed("the clipboard is unavailable".into()))
}
fn open_url(&self, client: Option<&str>, url: String) -> Result<(), HostError> {
let _ = (client, url);
Ok(())
@@ -882,7 +890,9 @@ pub struct StoreData {
pub(crate) invocation: Invocation,
/// The running call is a command or an event.
pub(crate) interactive: bool,
pub(crate) net_interactive: bool,
/// The user ran it: a command, or a view action other than a web view message.
/// Gates what must not happen unattended (`net:ask` prompts, reading the clipboard).
pub(crate) user_invoked: bool,
/// Editor window for pick, pick-many, input and confirm during action resolution.
pub(crate) action_prompt_client: Option<String>,
/// Tasks begun by the running call and not ended yet.
@@ -1132,7 +1142,7 @@ impl Runtime {
host: setup.host,
invocation: Invocation::default(),
interactive: false,
net_interactive: false,
user_invoked: false,
action_prompt_client: None,
open_tasks: Vec::new(),
last_report: None,
@@ -1783,7 +1793,7 @@ impl Runtime {
let result = self.call(invocation, self.limits.timeout, |e, store| {
let ctx = store.data_mut().new_invocation()?;
store.data_mut().interactive = true;
store.data_mut().net_interactive = true;
store.data_mut().user_invoked = true;
let r = e.plugin.openidea_plugin_commands().call_run(
&mut *store,
id,
@@ -1909,12 +1919,12 @@ impl Runtime {
if self.exports.views.is_none() {
return Err(CallError::missing_export("view-provider"));
}
let net_interactive = !matches!(&event, ViewEvent::Message { .. });
let user_invoked = !matches!(&event, ViewEvent::Message { .. });
let event = event_to_wit_view(event);
let result = self.call(invocation, self.limits.timeout, |e, store| {
let ctx = store.data_mut().new_invocation()?;
store.data_mut().interactive = true;
store.data_mut().net_interactive = net_interactive;
store.data_mut().user_invoked = user_invoked;
let views = e.views.as_ref().expect("checked");
let r = views.call_handle(&mut *store, view, &event, wasmtime::component::Resource::new_borrow(ctx.rep()));
store.data_mut().drop_invocation(ctx);
@@ -1966,7 +1976,7 @@ impl Runtime {
let data = self.store.data_mut();
data.invocation = Invocation::default();
data.interactive = false;
data.net_interactive = false;
data.user_invoked = false;
data.action_prompt_client = None;
// Tasks don't outlive the call that began them.
for id in std::mem::take(&mut data.open_tasks) {
+8
Переглянути файл
@@ -866,6 +866,14 @@ pub struct Endpoint {
pub location: Location,
}
/// The clipboard as `ui.read-clipboard` returns it (API 1.11): `None` for a kind it doesn't
/// hold; `image` is PNG bytes.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ClipboardContent {
pub text: Option<String>,
pub image: Option<Vec<u8>>,
}
/// A notification button that runs one of the publishing plugin's commands.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
+32 -1
Переглянути файл
@@ -353,7 +353,7 @@ impl StoreData {
/// their window; background and scheduled calls ask nobody, so only an
/// already-allowed host connects there.
fn ask_net(&mut self, host: &str) -> Result<Option<bool>, wit::Error> {
let client = self.net_interactive.then(|| self.invocation.client.clone()).flatten();
let client = self.user_invoked.then(|| self.invocation.client.clone()).flatten();
let subject = self.subject.clone();
let started = Instant::now();
let answer = self.host.net_ask(&subject, client.as_deref(), host, &self.cancel.token());
@@ -544,6 +544,37 @@ impl ui::Host for StoreData {
Ok(self.host.copy_to_clipboard(client.as_deref(), clip(text, crate::runtime::MAX_TEXT)).map_err(to_wit))
}
fn read_clipboard(&mut self) -> Fallible<ui::ClipboardContent> {
if let Err(e) = self.require(Capability::ClipboardRead) {
return Ok(Err(e));
}
// Never unattended: not from an event handler, a web view message or a command
// another plugin ran through `command-runner` (its chain is not empty).
let client = match &self.invocation.client {
Some(client) if self.user_invoked && self.invocation.command_chain.is_empty() => client.clone(),
_ => {
let why = "clipboard.read (only in a command or view action the user ran)";
return Ok(Err(wit::Error::Denied(why.into())));
}
};
let started = Instant::now();
let content = self.host.read_clipboard(&client, &self.cancel.token());
// The window may ask the user first: the wait doesn't count against the call's budget.
let waited = started.elapsed();
self.deadline += waited;
self.call_started += waited;
let content = match content {
Ok(content) => content,
Err(e) => return Ok(Err(to_wit(e))),
};
let max = crate::runtime::MAX_CLIPBOARD_BYTES;
if content.text.as_ref().is_some_and(|t| t.len() > max) || content.image.as_ref().is_some_and(|i| i.len() > max)
{
return Ok(Err(wit::Error::Failed(format!("the clipboard holds more than {} MiB", max >> 20))));
}
Ok(Ok(ui::ClipboardContent { text: content.text, image: content.image }))
}
fn open_url(&mut self, url: String) -> Fallible<()> {
let trimmed = url.trim();
let valid = (trimmed.starts_with("https://") || trimmed.starts_with("http://")) && trimmed.len() <= 8192;
+6 -5
Переглянути файл
@@ -91,15 +91,16 @@ fn the_sdk_carries_the_hosts_wit() {
#[test]
fn the_version_check_runs_compatible_components_and_explains_the_rest() {
let host = v("1.10.0");
for ok in ["1.0.0", "1.3.0", "1.4.7", "1.5.0", "1.6.0", "1.7.0", "1.8.0", "1.9.0", "1.10.0", "1.0.0-rc.1"] {
let host = v("1.11.0");
for ok in ["1.0.0", "1.3.0", "1.4.7", "1.5.0", "1.6.0", "1.7.0", "1.8.0", "1.9.0", "1.10.0", "1.11.0", "1.0.0-rc.1"]
{
assert_eq!(check_api(&v(ok), &host), Ok(()), "{ok}");
}
let newer = check_api(&v("1.11.0"), &host).unwrap_err();
assert!(newer.contains("1.11") && newer.contains("update OpenIDEA"), "{newer}");
let newer = check_api(&v("1.12.0"), &host).unwrap_err();
assert!(newer.contains("1.12") && newer.contains("update OpenIDEA"), "{newer}");
assert!(check_api(&v("2.0.0"), &host).unwrap_err().contains("update OpenIDEA"));
let older = check_api(&v("0.2.0"), &host).unwrap_err();
assert!(older.contains("rebuild it with the 1.10 SDK"), "{older}");
assert!(older.contains("rebuild it with the 1.11 SDK"), "{older}");
// 0.x: every minor is its own API.
assert_eq!(check_api(&v("0.2.0"), &v("0.2.5")), Ok(()));
assert!(check_api(&v("0.1.0"), &v("0.2.0")).is_err());
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
f6069ad2d31b629e4c99fbb800b3bf389ffb87ca7f24fc9cf7803fef68997ef5
c10d6f373bd3a701e201350d0272a211da72b23cef010144760db5bae44e2c11
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
178a2dd60891bfa56a02be322b47dfdbbf22f6e0a50ac56a4b7e4ae1520a821a
cd7a14b6d4464a559c197ba7fcba30fb045a8927c074fd0c310bec6039af0e0f
+336
Переглянути файл
@@ -0,0 +1,336 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "anyhow"
version = "1.0.104"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
[[package]]
name = "bitflags"
version = "2.13.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
[[package]]
name = "equivalent"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"
[[package]]
name = "foldhash"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
[[package]]
name = "hashbrown"
version = "0.17.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
dependencies = [
"foldhash",
]
[[package]]
name = "heck"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
[[package]]
name = "id-arena"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
[[package]]
name = "indexmap"
version = "2.14.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
dependencies = [
"equivalent",
"hashbrown",
"serde",
"serde_core",
]
[[package]]
name = "itoa"
version = "1.0.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
[[package]]
name = "leb128fmt"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
[[package]]
name = "log"
version = "0.4.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d15f86d12da44cd8d4ec3c73984537eb7f4cadcb9776a575a0a8a05ca11005c"
[[package]]
name = "macro-string"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e7b3a5bbb2f63aaa223a671ea1bd0e7bc16bd30ce387324cf63995deaddbbd2"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "memchr"
version = "2.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
[[package]]
name = "openidea-plugin"
version = "0.1.0"
dependencies = [
"serde",
"serde_json",
"wit-bindgen",
]
[[package]]
name = "openidea-test-clipboard"
version = "0.1.0"
dependencies = [
"openidea-plugin",
]
[[package]]
name = "prettyplease"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2bfe0f4c752e450fc2faf62654f1c134747922825d5b04ca717b8874f41a40c0"
dependencies = [
"proc-macro2",
"syn",
]
[[package]]
name = "proc-macro2"
version = "1.0.107"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
dependencies = [
"unicode-ident",
]
[[package]]
name = "quote"
version = "1.0.47"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
dependencies = [
"proc-macro2",
]
[[package]]
name = "semver"
version = "1.0.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
[[package]]
name = "serde"
version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
dependencies = [
"serde_core",
"serde_derive",
]
[[package]]
name = "serde_core"
version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "serde_json"
version = "1.0.154"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
dependencies = [
"itoa",
"memchr",
"serde",
"serde_core",
"zmij",
]
[[package]]
name = "syn"
version = "3.0.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "unicode-ident"
version = "1.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
[[package]]
name = "wasm-encoder"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4495a6f85dd94c411c749303efcbc5defade0b0cbdbc0541495241ab917a9b5a"
dependencies = [
"leb128fmt",
"wasmparser",
]
[[package]]
name = "wasm-metadata"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c86ff6668190d9fb70372b306b4f9fe8930f0e2f57ce72e4922bf2f117900949"
dependencies = [
"anyhow",
"indexmap",
"wasm-encoder",
"wasmparser",
]
[[package]]
name = "wasmparser"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "974d643b125b272607e2fff8012ea14a8328acd7621e4bafa7afb32500052b1b"
dependencies = [
"bitflags",
"hashbrown",
"indexmap",
"semver",
]
[[package]]
name = "wit-bindgen"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b85a987ab61d365382d25c7d47e26edd48941b3bf6e3fbf76eff918bc71dab06"
dependencies = [
"bitflags",
"wit-bindgen-rust-macro",
]
[[package]]
name = "wit-bindgen-core"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "775e122e390603abfacd548027016cd0113a6e2bf2f8ce6bdd3658b013456ea8"
dependencies = [
"anyhow",
"heck",
"wit-parser",
]
[[package]]
name = "wit-bindgen-rust"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "84e26e13b9d972026778d2ffb7985736de116026fdc8d9464f966e12df2eb240"
dependencies = [
"anyhow",
"heck",
"indexmap",
"prettyplease",
"syn",
"wasm-metadata",
"wit-bindgen-core",
"wit-component",
]
[[package]]
name = "wit-bindgen-rust-macro"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "16a008a0d6b4840677326beb4edbeb210a2f1b7d0183fb7cc33f466b90fd7fb6"
dependencies = [
"anyhow",
"macro-string",
"prettyplease",
"proc-macro2",
"quote",
"syn",
"wit-bindgen-core",
"wit-bindgen-rust",
]
[[package]]
name = "wit-component"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "078def49fdb49cab405c3006e05793b3fdaf7069126ba6b9c97d01ec8c98fe4c"
dependencies = [
"anyhow",
"bitflags",
"indexmap",
"log",
"serde",
"serde_derive",
"serde_json",
"wasm-encoder",
"wasm-metadata",
"wasmparser",
"wit-parser",
]
[[package]]
name = "wit-parser"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00f0dc051466ffe46787721fca3d088536f158ae400be044f1b1c386ba9397ad"
dependencies = [
"anyhow",
"hashbrown",
"id-arena",
"indexmap",
"log",
"semver",
"serde",
"serde_derive",
"serde_json",
"unicode-ident",
"wasmparser",
]
[[package]]
name = "zmij"
version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
+20
Переглянути файл
@@ -0,0 +1,20 @@
[package]
name = "openidea-test-clipboard"
version = "0.1.0"
edition = "2024"
publish = false
[workspace]
[lib]
crate-type = ["cdylib", "rlib"]
[dependencies]
openidea-plugin = { path = "../../../../../sdk/rust/openidea-plugin" }
[profile.release]
opt-level = "s"
lto = true
strip = true
codegen-units = 1
panic = "abort"
Бінарний файл не відображається.
+1
Переглянути файл
@@ -0,0 +1 @@
017cb719d8c3a226cb6178d75da7ae0396b2d78799658ef560f729e8e06f36e3
+25
Переглянути файл
@@ -0,0 +1,25 @@
# Test fixture: `ui.read-clipboard` (API 1.11) from a command, a view's button,
# a web view message and an event handler; only the first two are the user's.
id = "test.clipboard"
name = "Clipboard fixture"
version = "0.1.0"
engines.openidea = "^1.11"
wasm = "dist/plugin.wasm"
activation = ["on-command:*", "on-view:clipboard", "on-event:editor-focused"]
[capabilities]
optional = ["clipboard.read", "events"]
[[contributes.commands]]
id = "read"
title = "Read the clipboard"
[[contributes.commands]]
id = "last"
title = "What the last view action or event read"
[[contributes.views]]
id = "clipboard"
title = "Clipboard"
icon = "toolwindow-services"
location = "right"
+47
Переглянути файл
@@ -0,0 +1,47 @@
use openidea_plugin::views::{Body, Button, View, ViewEvent, Viewport, Views};
use openidea_plugin::{ClipboardContent, Error, Event, Invocation, Plugin, host, register_plugin};
/// `text=<text> image=<PNG byte count>`, `-` for what the clipboard doesn't hold.
fn describe(content: Result<ClipboardContent, Error>) -> String {
match content {
Ok(c) => format!(
"text={} image={}",
c.text.as_deref().unwrap_or("-"),
c.image.map_or("-".into(), |png| png.len().to_string())
),
Err(e) => format!("error: {e}"),
}
}
#[derive(Default)]
struct Clipboard {
/// What the last view action or event handler read.
last: Option<String>,
}
impl Plugin for Clipboard {
fn run_command(&mut self, id: &str, _: &Invocation, _: Option<&str>) -> Result<Option<String>, Error> {
match id {
"read" => Ok(Some(describe(Ok(host::read_clipboard()?)))),
"last" => Ok(self.last.take()),
_ => Err(Error::NotFound(id.into())),
}
}
fn handle_events(&mut self, _: &[Event], _: &Invocation) {
self.last = Some(describe(host::read_clipboard()));
}
}
impl Views for Clipboard {
fn render(&mut self, _: &str, _: Option<Viewport>, _: &Invocation) -> Result<View, Error> {
Ok(View::new(Body::Message("clipboard".into())).button(Button::new("read", "Read")))
}
fn handle(&mut self, _: &str, _: ViewEvent, _: &Invocation) -> Result<(), Error> {
self.last = Some(describe(host::read_clipboard()));
Ok(())
}
}
register_plugin!(Clipboard, views);
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
c39252e48882cb605286f95d1115a3293c191538d7762d1d3ce3afb1bfad814b
93a9660a0941f2f57d11ea7ae331bd6d209ddcb134729ee88ec2fd96e978e631
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
0809519ebb56f31b1f00d1e256a6d1af4e1c357990226ef949ac61f1e61989d6
6a0008339af0935c7c0128d23bf3e885a642c335ad57097cffb3f000766aba33
Loaded 100 of 543 files, more files were not shown because too many files have changed in this diff. Show more