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

...
Автор SHA1 Повідомлення Дата
l0ng-ai 47f8805045 fix(plugins): say which project a document-changed path is relative to
document-changed hands plugins the path relative to the file's own project, but
not which project that is. With two open projects holding the same relative
path, a plugin could not tell which document changed and cleared or kept the
wrong per-document state. The event now carries `project`, the root the path is
relative to, and the SDK's DocumentChanged exposes it (None from older IDEs).

Plugin components are rebuilt for the SDK change.
2026-11-18 22:12:29 +08:00
Akbar Husain 926a5424d1 perf(build): bound retained compile output, keep head and tail (#4025)
A compile step kept every line of its child's output in memory for the error summary, though each line is already streamed to the Build tool window. Compile steps now run through process::run_bounded, which keeps the head and tail of the output (and splits over-long lines) and marks the text as truncated; the error summary says when lines may be missing. Callers that parse a successful run's output (Gradle model and tasks, Gradle dependencies, Maven dependency trees and sources) keep using process::run with full retention.

Co-authored-by: akbar1214 <[email protected]>
2026-11-18 21:53:57 +08:00
MyRRR f1aa47e762 feat(editor): structured Julia syntax highlighting (#4161)
Julia used CodeMirror's legacy StreamLanguage mode, which has no tags for function calls, type names or macros. It now uses Pluto's MIT-licensed Lezer grammar (@plutojl/lang-julia), with call targets tagged as function names, and Julia joins the language-scoped Color Scheme settings with a preview sample.

Co-authored-by: Royshare <[email protected]>
2026-11-18 21:50:17 +08:00
l0ng-ai 305dbdc316 fix(gradle): show resolvable configurations for the selected project (#4281)
Dependency Analyzer offered a fixed list of configurations, so a custom resolvable configuration couldn't be selected. It now lists the configurations Gradle reports as resolvable for the selected project, custom ones included, and syncs projects whose configuration data is missing or stale when it opens. Configurations used only to declare dependencies are excluded.
2026-11-18 21:46:45 +08:00
Mamaev Igor 0a4f2fc1df fix(vim): move between notebook cells with j and k (#4317)
In a notebook with Vim enabled, Normal-mode j on a cell's last line and k on its first line now continue into the next or previous cell that shows an editor (code, or Markdown being edited), at the same column; Markdown previews and raw cells are skipped. Counts, operators and registers (3j, dj) stay inside the cell. Notebooks provide the neighbouring editor through a new adjacentEditor facet.

Co-authored-by: pxc1984 <[email protected]>
2026-11-18 21:45:04 +08:00
Mr0Bread 93210c8c04 fix(agents): refresh models in existing chats (#4062)
An existing chat only offered the models its session reported. Its composer now uses the same searchable model picker and Refresh models control as New Agent Task. A model that only the fresh catalog lists is tried on the live session first; if the agent rejects it and the session is idle and resumable, the choice is kept as pending, the live process is recycled, and the next message reloads the same session and applies it through the existing wanted-settings path. If the reload can't apply it, the previous model is restored and the error reported without sending.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-18 21:43:50 +08:00
Vladislav Kuzmin c52067f815 fix(database): support ClickHouse HTTP endpoints without session affinity (#4316)
Behind an endpoint that alternates replicas, the named HTTP session opened by Test Connection was missing on the next node (code 372), so the data source could not connect. Setting use_http_session=false in a data source's Advanced properties sends each request without a session, carrying its own database, settings and limits; startup scripts are rejected in that mode. Named sessions stay the default and now run USE for the configured database, since the HTTP database parameter applies only to the request carrying it. A lost session reports how to fix it and never replays the user's SQL.

Co-authored-by: principalwater <[email protected]>
2026-11-18 21:39:34 +08:00
Moler1995 fce37c5627 fix(vim): sync registers with the system clipboard and route paste/copy per mode (#4136)
The "+ and "* registers read and write the system clipboard (CRLF normalised, linewise when the text ends with a line break), Insert-mode Ctrl+V / Shift+Insert paste and Visual-mode Ctrl+C copy. A new clipboard option (default ideaput,autoselect) controls the unnamed register: set clipboard+=unnamed or clipboard=unnamedplus in .ideavimrc mirrors yanks, deletes and changes to the system clipboard; by default they stay in Vim's registers. "+ is read through the native clipboard where the backend provides it.

Co-authored-by: Moler1995 <[email protected]>
2026-11-18 21:38:01 +08:00
liziing 90df4ba48e fix(vcs): show declaration icons in the Compare tool window (#4300)
The Compare tool window chose every icon from the file name alone. When a revision is compared with the working tree, files that still exist now take their icon from the shared file presentation cache, as the Project tree does: Java and Kotlin classes, interfaces and tests, and Spring config files. Deleted files and comparisons between two revisions keep their file-type icons.

Co-authored-by: liziing <[email protected]>
2026-11-18 21:33:45 +08:00
l0ng-ai c3034b25e8 Stage TODO and Vim preferences until Settings applies them (#4283) 2026-11-18 21:32:25 +08:00
l0ng-ai b5c2a84d5d Keep file type association edits on the visible selection (#4282) 2026-11-18 21:32:17 +08:00
lleviathe 723666891d feat(settings): indent dependent options under their checkbox and disable them while unchecked (#4308)
A checkbox option on a declarative settings page can have children, rendered indented under it and disabled while it is unchecked, like the editor pages already do. IDE MCP Server's Port is the first one, under Use a fixed port; both search indexes still list it.

Co-authored-by: lleviathe <[email protected]>
2026-11-18 21:30:35 +08:00
lleviathe 268f12349f fix(settings): space hints from their control and start checkbox hints at the checkbox text (#4306)
Hints now sit 4px below their control, and checkbox hints start at the checkbox text (box plus label gap) on both declarative and editor settings pages.

Co-authored-by: lleviathe <[email protected]>
2026-11-18 21:30:31 +08:00
lleviathe 4dfdbd35fd fix(settings): keep wrapped hints from overlapping the next row in WebKit (#4305)
WebKit sizes an auto grid row from its item's height at an earlier width, so after the Settings window narrowed, a hint that wrapped to one more line lay over the row below. The form group and row grids now use grid-auto-rows: min-content.

Co-authored-by: lleviathe <[email protected]>
2026-11-18 21:30:26 +08:00
l0ng-ai 281b093774 fix(todo): include live matches from all files in Open Files scope (#4279) 2026-11-18 21:29:54 +08:00
l0ng-ai a55394782a Apply Vim mappings when reloading from Settings (#4278) 2026-11-18 21:29:47 +08:00
l0ng-ai ede72f0941 fix(startup): don't time out while the Trust Project prompt waits for an answer (#4321)
A window opened for an untrusted project asks Trust Project over the splash. The 60-second startup watchdog in boot.js kept counting while the prompt was up, so answering after a minute replaced it with the startup failure page. askOverSplash now signals when a question starts and ends, and the watchdog pauses for that time, as it already does while the window is hidden.
2026-11-18 21:25:58 +08:00
l0ng-ai 3ed4fa6836 fix(vcs): keep worktree operation errors through refresh (#4271) 2026-11-18 21:20:10 +08:00
l0ng-ai 4990a90bbf Keep build selections when reloading the .NET workspace (#4267) 2026-11-18 21:14:17 +08:00
l0ng-ai 762b509b66 fix(coverage): keep asynchronous results with their project (#4260) 2026-11-18 21:05:39 +08:00
l0ng-ai 2964b2ffc5 Ignore Logcat callbacks from superseded streams (#4259) 2026-11-18 21:05:16 +08:00
l0ng-ai 704952a6ae fix(build): ignore completions from superseded requests (#4258) 2026-11-18 21:05:07 +08:00
l0ng-ai 65007093e7 Confirm before replacing a saved macro recording (#4256) 2026-11-18 21:03:14 +08:00
l0ng-ai 696ab0c3ba fix(http-client): pin the starting environment for request batches (#4255) 2026-11-18 21:01:37 +08:00
l0ng-ai e282546697 Isolate GitHub review drafts by pull request context (#4252) 2026-11-18 20:55:46 +08:00
l0ng-ai 93fb7b6a85 fix(search): keep an empty Directory scope inactive (#4250) 2026-11-18 20:53:07 +08:00
Mr0Bread e691aa9fb3 fix(ui): remeasure popup height before choosing a side (#4296)
The shared Popup decided where it fit using the max-height cap from its previous placement, so a popup clipped below its anchor still looked as if it fit there: the agent Composer's @ list stayed clipped after erasing the filter or when file results arrived after it opened. A middleware now clears the old cap before flip, and the size step only caps a popup that is taller than the space available.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-18 20:35:10 +08:00
acaoтаamphetamlne 44a12abbd7 perf(vfs): compact adjacent duplicate modification events (#3276)
Adjacent, exactly identical single-path Modify(Any/Data/Metadata) notifications (same path spelling, event and process id) are merged before they accumulate in the debounce queue; create/remove/rename, multi-path and flagged events are kept, and the first/last arrival times are kept so the 100 ms debounce and 1 s maximum delay don't move. A debug-level "file watcher batch" line reports received/queued counts and queue, processing and callback times.

Co-authored-by: amphetamlne <[email protected]>
2026-11-18 20:33:50 +08:00
GuoYuтаguoyucode 497b25bf4a fix(mcp): say projectPath defaults to the connection's project (#4262)
Every MCP tool described projectPath as optional only when one project is open, so agents with several projects open passed it on every call. The description now matches resolve_project: the call's projectPath, then the connection's project (?project= / X-OpenIDEA-Project), then the only open project.

Co-authored-by: guoyucode <[email protected]>
2026-11-18 20:31:47 +08:00
l0ng-ai 4ecfb98c94 fix(local-history): keep a file's content from before its first edit (#4302)
A file with no Local History entries had nothing to revert to at a label put before its first save. The first edit of an open document now records the file's content on disk as an "Original" snapshot when the file has no history yet, dated by its modification time (but not before the oldest entry kept, so retention and working days are unaffected). A label put before the edit finds it; a file written after the label is dated after it.
2026-11-18 20:29:55 +08:00
l0ng-ai f1d6b0dc1b fix(nav): drop a useless conversion clippy rejects (#4301) 2026-11-18 20:27:21 +08:00
Bert Verhelstтаbertyhell f2cfe38931 feat(agents): view and roll back the last turn's changes (#4042)
The agent session's Changes pane gets a Whole Task / Last Turn switch. Each turn records a baseline the way a task records its start (HEAD, the stamped list of changed files and copies of them in the task store, reusing copies of files unchanged since the previous turn); Last Turn lists only what the last turn changed, diffs against the file as that turn started, and Rollback restores only that turn's changes. Accept still brings over the whole task. Host-side behind agent_changes / agent_base_text / agent_rollback_changes (lastTurn view), so remote development works the same way.

Closes #3689

Co-authored-by: bertyhell <[email protected]>
2026-11-18 20:22:19 +08:00
l0ng-ai d18ac58b56 feat(lsp): configure a language server from the status bar popup (#4298)
Each server in the Language Servers popup gets a Configure button that opens Settings › Language Servers on that server's language with the server selected, where the interchangeable servers are chosen and additional ones turned off. tools.languageServers takes the server name and opens the page as languages.servers#<name>; the page selects that tool and scrolls its language into view.
2026-11-18 20:08:31 +08:00
Vladislav Kuzmin 0021a764c3 fix(database): connect to ClickHouse accounts with strict read-only settings (#4292)
A ClickHouse account with server-enforced readonly = 1 rejected the HTTP driver's own per-query settings (Code 164) on the connection probe. When the probe fails on one of those settings, the driver checks getSetting('readonly') in the same session and, only when it is 1, sends further requests without its own settings (the server then provides write protection; the client still caps the grid rows). A writable session that reports the error keeps failing as before.

Closes #4275

Co-authored-by: principalwater <[email protected]>
2026-11-18 20:01:45 +08:00
Mollo-i a30103d410 feat(nav): @property@ in YAML and properties resources jumps to its pom properties entry (#4243)
Go to Declaration on a Maven resource-filtering placeholder (`@profileActive@` in `application.yml` or `application.properties`) jumps to the `<properties>` entry that defines it: the nearest `pom.xml` above the resource, up through the project root, is searched along its parent chain with the lookup the pom's own `${property}` navigation uses (now exposed as `ide_build::maven::property_declaration`). Plugin definition providers still run, with the pom result first.

Closes #4241

Co-authored-by: Greenker <[email protected]>
2026-11-18 20:00:25 +08:00
Mollo-i 89798baa3c fix(lsp): a Maven resource-filtering placeholder no longer fails YAML parsing (#4242)
yaml-language-server reports "Plain value cannot start with reserved character @" for unquoted Maven placeholders such as `spring.profiles.active: @profileActive@`, which Maven replaces before the file is read as YAML. The diagnostic is dropped when its scalar is exactly an `@token@` placeholder; other parser errors (an unpaired `@`, a different message, a stale range) still show.

Co-authored-by: Greenker <[email protected]>
2026-11-18 20:00:10 +08:00
l0ng-ai c09c9b8aaf docs: describe the Linux DMA-BUF workaround for unresponsive windows (#4295)
The troubleshooting entry still said NVIDIA on Wayland gets WEBKIT_DISABLE_DMABUF_RENDERER=1; since #2179 the app turns the driver's explicit sync off instead. The entry now covers windows that stop reacting to input, notes the slower CPU drawing, and shows how to keep the variable for menu launches.
2026-11-18 19:50:24 +08:00
l0ng-ai 995a9563f7 feat(profiler): navigate and zoom the flame graph with the keyboard (#4294)
The flame graph had no keyboard focus target. It is now focusable with a current frame (outlined, announced via aria-activedescendant): Up/Down go to callee/caller, Left/Right to neighbours, Enter zooms, Escape resets, F4 opens the source. Fixes #4209.
2026-11-18 19:45:37 +08:00
l0ng-ai 893d9af6e6 fix(inspections): Rerun Inspection repeats the file its results are for (#4291)
A Current file inspection stored its unresolved scope, so Rerun resolved it to whichever file was active. The run now records the file it inspected and Rerun inspects that file again. Fixes #4234.
2026-11-18 19:42:27 +08:00
l0ng-ai 73496669e7 fix(web): the built-in preview reloads only for the page and web resources (#4290)
The HTML preview reloaded on any project file change or document save, so editing notes.txt cleared the page's inputs and scroll position. It now reloads when the page itself or a web resource changes. Fixes #4231.
2026-11-18 19:41:01 +08:00
l0ng-ai add914f7fb fix(markdown): a word double-clicked in the preview leaves out the space after it (#4288)
On Windows a double-click selects the word plus the following space, so the preview's selection highlights and Find used "Order ". A word selection's trailing whitespace is now dropped from the text and, when it ends in a text node, from the selection itself. Fixes #4230.
2026-11-18 19:37:24 +08:00
l0ng-ai 0fd0f08865 fix(search): Replace All saves open documents that had no unsaved changes (#4286)
Replace All saved only files it opened itself, so a file the search preview held open got the replacement in memory but not on disk. Documents without unsaved changes are now saved after the replacement; buffers the user is editing are left unsaved. Fixes #4202.
2026-11-18 19:35:26 +08:00
l0ng-ai 054d2ba517 fix(toolwindows): show Hide All Tool Windows as Restore Tool Windows when it restores (#4277)
With every window hidden, Hide All restores them but kept its Hide label. The actions registry gets retitleAction for titles that follow state; the action and its menu label read Restore Tool Windows while a hidden set can be restored. Fixes #4162.
2026-11-18 19:27:54 +08:00
l0ng-ai 738dc12ef7 fix(libraries): clear the previous project's External Libraries on switching (#4276)
The External Libraries node and last complete result were kept across a project switch until the new discovery answered, so the new project showed and filled in the old project's libraries. Refreshing for another project now clears them first. Fixes #4194.
2026-11-18 19:26:48 +08:00
l0ng-ai 6135a5326d fix(local-history): reverting to a label leaves files deleted before it absent (#4274)
A file whose last revision before a label is its Deleted snapshot was absent at the label, but Revert restored it and counted it. Folder reverts now skip such files; a file's own revert says it did not exist then. Part of #4199.
2026-11-18 19:22:37 +08:00
l0ng-ai 403bb28ca4 fix(local-history): keep snapshots as document text (no BOM, LF) (#4272)
Saves record the document's text but the watcher snapshotted the file with its BOM and CRLF, adding an External change revision per save; reverting that revision doubled the BOM. Disk snapshots and snapshot content are now normalized to document text. Fixes #4195.
2026-11-18 19:21:04 +08:00
l0ng-ai 3249d4ee90 fix(lsp): count a Rust error once when rust-analyzer and rustc both report it (#4270)
rust-analyzer publishes its own analysis next to cargo check's, so one type mismatch arrived as rust-analyzer(E0308) and rustc(E0308) and counted twice. Its own entry is dropped when rustc reports the same code and severity over an overlapping range. Fixes #4193.
2026-11-18 19:18:46 +08:00
l0ng-ai 79e41c85ff fix(build): resolve Build Module's Cargo diagnostics from the workspace root (#4269)
rustc names workspace members' files from the workspace root; Build Module runs cargo in the member, so its diagnostics doubled the member folder. Resolution now tries the manifest directory, then its ancestors, taking the first existing file. Fixes #4189.
2026-11-18 19:17:01 +08:00
l0ng-ai f0a7cca1b1 fix(project-view): say which view option hides a file Select Opened File can't reach (#4268)
With Show Excluded Files or Show Hidden Files off, Select Opened File silently selected the nearest shown ancestor. It now notifies which option hides the file, with an action that turns it on and selects the file. Fixes #4181.
2026-11-18 19:15:14 +08:00
l0ng-ai 21f1e2bbb4 fix(editor): don't carry untitled tabs to the Welcome screen (#4264)
Untitled tabs were carried when Close Project returned to Welcome, after the leave guard had asked about them, so a draft discarded with Don't Save reopened as an empty focused tab. Closing to Welcome now drops them; in-place switches still carry them. Fixes #4173.
2026-11-18 19:11:22 +08:00
l0ng-ai ffdb5d74f2 fix(navigation): Navigate to Test uses the top-level class at the caret (#4263)
Navigate to Test derived test names from the file name, so with the caret in a second top-level class it offered the file's test instead. For Java, Kotlin, Scala, Groovy and C# it now takes the outermost type around the caret from the document outline, falling back to the file name. Fixes #4171.
2026-11-18 19:08:21 +08:00
l0ng-ai d4d9e7d191 fix(editor): tab limit keeps VCS-changed tabs with Close non-modified files first (#4261)
The tab limit's closing policy only counted unsaved changes as modified, so a saved file with a Git change closed before clean tabs. It now shares Close Unmodified Tabs' check: unsaved changes or a VCS status. Fixes #4166.
2026-11-18 19:05:43 +08:00
l0ng-ai 6a41509fd2 fix(project-trust): list restricted projects in Project Trust settings (#4257)
A project with a restricted decision stays restricted inside a trusted location, but the settings page didn't list those decisions. The page now lists restricted projects with a Trust button, and the location hint says restricted projects are excluded. Fixes #4156.
2026-11-18 19:03:39 +08:00
l0ng-ai 6efece99a4 fix(project): ask about trust before leaving the current project (#4253)
Opening a folder in this window confirmed leaving the current project (which stops its running processes) before the trust prompt, so Don't Open left the original project without its processes. Trust is now asked first; the fallback open path follows the same order. Fixes #4160.
2026-11-18 19:00:24 +08:00
l0ng-ai 0fab45689f fix(vcs): expire the conflict notice once the merge or rebase is over (#4251)
"All conflicts resolved" kept its Commit… and Abort Merge actions after the
merge was committed, and Abort Merge then reported no merge in progress. The
conflict notices (key vcs.conflicts) now expire when the repository leaves
the merge, rebase, cherry-pick, revert or am they refer to, however it ended.

Fixes #4154
2026-11-18 18:53:43 +08:00
l0ng-ai 71090202b6 fix(debugger): Breakpoints dialog selects on click and keeps typed conditions (#4249)
A single click on a breakpoint jumped to its source and closed the dialog,
and a condition typed and confirmed with Enter (Done) was lost, as only
leaving the field saved it. A click now selects the breakpoint (double-click
or Enter goes to the source), and the shown breakpoint's typed fields are
saved when the dialog closes or another breakpoint is shown, for method and
field breakpoints too; unchanged fields are not written again.

Fixes #4150
2026-11-18 18:52:04 +08:00
l0ng-ai 8ed08510ed fix: Delete in a popup's search field edits the text before it removes the selection (#4248)
Open Recent removed the selected project on Delete wherever the caret was in
the search field, and the run configuration chooser deleted the selected
configuration without asking. Delete now acts on the selection only when it
has no text to delete (the caret at the end of the query, nothing selected;
⌘⌫ only with an empty query), and the chooser asks before deleting a
configuration, from Delete or its menu, as IDEA's popup does.

Fixes #4159
Fixes #4203
2026-11-18 18:48:03 +08:00
l0ng-ai 500df4ffc4 fix(vcs): Show Diff of a staged or unstaged row shows that side of the index (#4247)
The changes tree's Show Diff passed only the file's path to the action, which
opened HEAD against the working copy, so a partially staged file showed its
unstaged edit from the Staged group too. The menu item now opens the row's own
diff, as double-click does: HEAD ↔ Index under Staged, Index ↔ working copy under
Unstaged. Show Diff from the keyboard builds the tree the Commit window shows
(staging groups, no change lists, with the staging area) so the selected row is
found, and uses it with the non-modal interface too.

Fixes #4152
2026-11-18 18:45:05 +08:00
l0ng-ai 81aa9418aa fix(vcs): no Commit File… in the changes tree with the staging area (#4246)
With the staging area the commit takes the whole index, so Commit File… on a
staged file only focused the message and committed every staged file. The
item is left out of the changes tree's menu while the staging area is on, as
the staging tree has no per-file commit.

Fixes #4153
2026-11-18 18:39:57 +08:00
acaoтаamphetamlne 706ce87cb7 test(plugins): exercise fuel renewal with explicit CPU work (#3438)
Keeps main's 40,000 foreground fuel budget and patient CPU workload, and adds a quiet mode that runs the same workload without task reports and must exhaust the scaled budget, so beginning a task alone is shown not to renew it. The Git capability setup now fails the test instead of returning early. Production limits are unchanged.

Co-authored-by: amphetamlne <[email protected]>
2026-11-18 18:38:14 +08:00
胡翀таzzxzz12345 4e5dbc8e0c feat(markdown): render LaTeX math with KaTeX (#4138)
Markdown views (file preview, agent chat, notebook Markdown cells, LSP/GitHub/plugin Markdown) now typeset $...$, $$...$$, \(...\), \[...\] and ```math blocks with KaTeX. The marked extension emits [data-math] placeholders that survive DOMPurify and are typeset after sanitizing (trust: false); inline $ follows Pandoc's rules, so currency like $5 and $10 stays text. The Markdown preview keeps the placeholders in its rendered HTML and typesets them after each render, like Mermaid diagrams, so its per-block sanitize cache is unaffected.

New dependency: katex 0.19.1 (MIT).

Co-authored-by: zzxzz12345 <[email protected]>
2026-11-18 18:36:43 +08:00
Deng Liuтаdengliu 79accd1311 perf(settings): split Settings and auxiliary window boot out of the Workbench module (#4044)
Native auxiliary windows (settings, comparison, diff, deployment) all booted src/main.tsx, which statically imported the Workbench and every workbench feature (CodeMirror, xterm, editor extensions) even when the Settings window rendered none of them. main.tsx is now a small window-kind router with one boot module per window kind, and the settings pages, core plugin points and plugin theme runtime are registered from editor-free modules, so the Settings window loads no Workbench, @codemirror, @xterm or @/editor modules (about 57% less JS and a third less heap per Settings window). A static test keeps the Settings boot isolated.

Part of #3942

Co-authored-by: dengliu <[email protected]>
2026-11-18 18:32:14 +08:00
Deng Liuтаdengliu 85d02e03f9 feat(agents): discover MCP servers from installed Copilot CLI plugins (#4029)
MCP servers bundled in installed GitHub Copilot CLI plugins (installedPlugins in ~/.copilot/config.json) were started by Copilot CLI in sessions but never listed in Session MCP Servers or Agent Configs, so they could not be seen, disabled per session or imported. External discovery and import now also read each enabled plugin's .mcp.json / plugin.json mcpServers inside its cache_path (paths kept within the plugin root), expand ${COPILOT_PLUGIN_ROOT} / ${CLAUDE_PLUGIN_ROOT} / ${PLUGIN_ROOT}, and honour disabledMcpServers and enabledPlugins in ~/.copilot/settings.json.

Co-authored-by: dengliu <[email protected]>
2026-11-18 18:18:21 +08:00
Ernstjan FreriksтаEjaYF e689c95e93 feat(database): create and drop databases and schemas from the tree (#4201)
The Database tree gets New > Database... and New > Schema..., and Drop... on database nodes (PostgreSQL, MySQL/MariaDB schemas, SQL Server), each with a preview of the statement it runs.

Creating closes the IDE's own connections to the database the server copies (the template on PostgreSQL, model on SQL Server), which both refuse to copy while it has sessions. Dropping closes the IDE's pools and sessions of that database first and runs DROP DATABASE on the data source's default database; "Close the sessions of other clients" adds WITH (FORCE) on PostgreSQL 13+ and single-user mode on SQL Server. Drop is refused for the data source's own database and read-only data sources. Both go through withConnection, so a password the data source does not save is asked for first.

Closes #3189

Co-authored-by: EjaYF <[email protected]>
2026-11-18 18:17:18 +08:00
faithererer bb243909bf feat(vcs): suggest branch name prefixes in the New Branch dialog (#4219)
Typing a name in Create New Branch now suggests the folders of existing local branch names (typing `fe` offers `feat/`, `feat/2610/`, `feat/2610/08/`), shallowest first. Arrow keys pick one, Enter or Tab fills it in and keeps typing; Enter without a pick creates the branch as typed. Remote branches are left out of the suggestions.

Closes #4208

Co-authored-by: faithererer <[email protected]>
2026-11-18 18:00:55 +08:00
HL-SLCтаHL-slc 64544a4edd fix(database): don't read data sources after the project is closed (#4226)
Closing the project resets the database state to not loaded while an open SQL file's console bar is still mounted; its effect called loadSources() with no project open and showed "Cannot read data sources: no project is open in this window". loadSources() now returns early without a project; the next project loads its sources as before.

Co-authored-by: HL-slc <[email protected]>
2026-11-18 17:58:16 +08:00
l0ng-ai 4fd1e4356e fix(java): keep jdtls temporary files in its workspace and clear them at start (#4238)
JDT APT copies a project's annotation processor jars into a new jdt-apt-*
folder in the system temp directory for each processor class loader, and
deletes them only when the JVM exits normally. jdtls stopped by the IDE never
does, and on Windows the jars are still open at exit, so every start left
another copy behind (tens of GB in %TEMP% after a while).

jdtls now gets -Djava.io.tmpdir=<workspace>/.tmp for the workspaces the IDE
creates, and that folder is emptied before each start. A temp directory set in
the user's JVM arguments, and a -data workspace of the user's own, are left
alone.

Fixes #4192
2026-11-18 17:56:21 +08:00
l0ng-ai 1794cd4fbb fix(database): table tabs keep their filter, sort and page when switching tabs (#4236)
Table editor tabs unmounted when another tab was shown, so their WHERE / ORDER BY
text, paging and unsubmitted edits were lost and the rows were queried again.
Table tabs are now kept alive like other editors, and the view state (filter,
sort, page) is remembered per table so a tab that is closed and reopened, or
dropped from the kept set, starts from the same view.

Fixes #4158
2026-11-18 17:47:32 +08:00
Bert Verhelstтаbertyhell 10d39e14ca feat(php): align key-value pairs and consecutive assignments when formatting (#4045)
Settings › Editor › Code Style › PHP gets an Alignment section with Align key-value pairs (=> in multi-line arrays) and Align consecutive assignments (= in assignment statements on consecutive lines), both off by default. The backend applies them after whichever formatter ran (language server, PHP-CS-Fixer or a plugin formatter), for Reformat Code, format on save and the Reformat dialog; a selection changes only its lines. Alignment walks the PHP tree-sitter tree per array and statement list, so operators inside strings, comments, heredocs, foreach, arrow functions, match and default parameters are never touched.

Closes #3889

Co-authored-by: bertyhell <[email protected]>
2026-11-18 17:42:39 +08:00
l0ng-ai 101890ab4c fix(mcp): execute_run_configuration resolves a Java application's classpath (#4215)
MCP runs started a JVM application configuration as written, so ${classpath} reached java literally and the main class was not found. Application and Spring Boot configurations now go through the Run tool window's launch preparation (ops::java::resolve_launch): build per the configuration's policy (including the delegated Maven build), resolve ${classpath} / ${testClasspath}, the module path and the module's JDK, find a missing module from the main class, and stop on compile errors unless the policy continues on errors. Before-launch runs of such configurations are resolved the same way.

Fixes #4127
2026-11-18 17:20:47 +08:00
usong 86778d259f fix(editor): locate Lombok accessors and Java fields in library sources (#4190)
Go to Definition into a dependency's Lombok entity landed on the class header or the @Getter/@Setter annotation: library source lookup recognized Java methods but not fields, and never mapped a generated get/set/is accessor back to its field. Java field declarations (with or without an initializer) are now located, accessors map to their field when no method of that name is declared, and a jdt: library class uses the source declaration only when jdtls' range does not name the member, so overloads keep jdtls' exact range.

Closes #4186

Co-authored-by: usongon <[email protected]>
2026-11-18 17:12:47 +08:00
Bin 59c39a7e77 fix(editor): collapse multiline imports after the import keyword (#4170)
An import group whose first statement spans several lines folded from the end of its header line, leaving the first specifier visible. The fold now starts after the import keyword, so the editor shows `import …`, and the gutter finds an imports fold that starts inside its header line. Go and Rust delimiter handling is unchanged.

Co-authored-by: ffgenius <[email protected]>
2026-11-18 17:08:22 +08:00
Muuтаmuutot 4d45ddc5a5 fix(editor): a fold click can miss folds that arrived asynchronously (#4165)
CodeMirror's fold gutter rebuilds its chevrons only on document, viewport or language changes, but backend folding ranges arrive through setBackendFolds, so a chevron could sit at a stale line and a click did nothing. The placeholder chip resolved its fold through the clicked line block, which can miss a fold starting at a line boundary (a Python docstring, an Allman header). The gutter now rebuilds whenever the backend fold field changes, and the chip resolves the fold at its own position, falling back to CodeMirror's handler.

Closes #4082

Co-authored-by: muutot <[email protected]>
2026-11-18 17:06:47 +08:00
Bert Verhelstтаbertyhell bfd6f01471 perf(markdown): sanitize only the changed blocks when the preview re-renders (#4041)
The Markdown preview re-sanitized the whole document with DOMPurify on every settled edit. It now caches each block's sanitized HTML and sanitizes only the blocks an edit changed; a block whose markup carries into the following blocks (unclosed tags, comments, form state) falls back to sanitizing the whole document, so the output is the same.

Part of #3940

Co-authored-by: bertyhell <[email protected]>
2026-11-18 17:04:44 +08:00
Bert Verhelstтаbertyhell 895d042dd7 perf(problems): rebuild only the changed file's Problems entries per diagnostics update (#4040)
A diagnostics event for one file made the Problems view merge, filter and sort every file's diagnostics again, and the tab header and tool window badge recounted every error in the workspace. Each file's merged list and Problems node are now cached by its sources map (replaced only when that file changes), and the store keeps project severity counts up to date per event, recomputing them on a profile change. Output is unchanged.

Part of #3937

Co-authored-by: bertyhell <[email protected]>
2026-11-18 17:04:39 +08:00
Bert Verhelstтаbertyhell eb37d9e96a perf(search): claim the match budget while a file is searched, not after it (#4043)
Each file claimed its matches from the shared budget only after it was fully searched, so a broad Find in Files query over dense files could build up to the whole budget once per walker thread and throw most of it away. Files now claim matches in batches of 64 as they find them; a binary file gives its claim back, and a non-UTF-8 file searched again as decoded text fills its byte search's claim. When the limit is hit, exactly the budget is returned. Adds a dense-files bench with a budget.

Part of #3939

Co-authored-by: bertyhell <[email protected]>
2026-11-18 16:58:56 +08:00
Bert Verhelstтаbertyhell dc8ae96206 perf(text): diff a document without copying its whole rope (#4039)
Document::diff copied the whole rope into a String and counted UTF-16 units across the unchanged prefix before trimming the common ends. The common ends are now found by walking the rope's chunks against the new text, only the changed middle is copied, and the prefix's UTF-16 offset comes from the rope's metadata. The trimmed (prefix, suffix) is unchanged, so the change sets are too. Adds a 5 MB one-edit diff bench with a budget.

Part of #3938

Co-authored-by: bertyhell <[email protected]>
2026-11-18 16:57:29 +08:00
l0ng-ai e70bca39ee fix(editor): autosave leaves a file changed on disk after an edit (#4197)
After an external change to a file whose buffer had unsaved edits, the next autosave wrote the buffer over the disk change despite the conflict warning. The document store now remembers the conflict and the new doc_autosave command declines to write such a buffer; an explicit save still overwrites and a reload clears the conflict.

Fixes #4115
2026-11-18 16:55:49 +08:00
l0ng-ai 2fe09e73f5 fix(editor): a document closed with changes no longer counts as unsaved (#4196)
Closing a modified document with Don't Save left the backend dirty flag set, so the exit guard asked about it again on Exit. The document store now reports a buffer clean when it is closed.

Fixes #4118
2026-11-18 16:54:23 +08:00
l0ng-ai b921de184b fix(editor): keep a modified file open when its last tab closes without autosave (#4191)
With autosave off, closing the only tab of a modified file disposed its document and lost the edits. As in IDEA, DocumentManager.release keeps a dirty (non-untitled) document open without a tab: reopening shows the edits, Save All and the exit check still cover them; also when autosave on close fails.

Fixes #4116
2026-11-18 16:43:51 +08:00
l0ng-ai 23739c90c7 fix(run): Run starts another instance of a configuration that allows multiple instances (#4187)
run.run reran the selected configuration's running session even with Allow multiple instances, stopping the process. As in IDEA (Rerun/Stop only for configurations that don't run in parallel), such a configuration keeps Run/Debug in the toolbar and Run starts another instance; a tab's Rerun still restarts its session.

Fixes #4148
2026-11-18 16:39:53 +08:00
LU XIANGRUIтаwildcatDownstairs 923325aeae feat(color-scheme): foreground for Identifier under caret (#4135)
Identifier under caret and Identifier under caret (write) can now set a Foreground, as in IDEA; imported .icls schemes carry it too. The highlight mark wraps the syntax and semantic token spans, so the colour is applied with the inherited -webkit-text-fill-color: unset, the declaration drops and tokens keep their syntax colours; find matches, selection, links, inlay hints and fold placeholders keep their own colours. Multi-line highlights colour only the highlighted text, not the indent.

Closes #4109

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 16:37:49 +08:00
LU XIANGRUIтаwildcatDownstairs d7351dca1d feat(run): Python run configuration type (#4126)
Adds PyCharm's Python configuration: a script or a -m module with arguments, command (interpreter or uv/poetry) and runner arguments; a plain python/python3 runs on the project interpreter as before. Existing python configurations (detected, imported, run from the context menu) open in this form when their command line maps to a script or module. projectPython prefers a detected python configuration over one made by hand.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 16:36:56 +08:00
l0ng-ai 8959f7aa5d fix(debugger): answer the debuggee terminal's cursor position query (#4185)
Python debugging on Windows timed out waiting for debugpy's launcher: since #3374 it runs through runInTerminal on a ConPTY, which asks the terminal for the cursor position (ESC[6n) and starts the program only after the answer; the debug console never answered. The runInTerminal output forwarder now answers cursor position queries and drops them from the output. A runInTerminal test now runs on Windows too.

Fixes #4123
Fixes #4141
2026-11-18 16:34:54 +08:00
l0ng-ai 5e4f187107 fix(settings): detect SDKs and install tools from Settings without a project (#4184)
SDK combos in Settings opened from the Welcome screen loaded forever: sdk_detect and the interpreter/tool commands were Trusted and called require_trust, which refuse a window without a project, and useDetected kept loading after a failed detection. They are now OutsideRestricted with Host::require_trust_if_project (still refused in Restricted Mode; commands that take a project path keep the strict check), and a failed detection ends loading.

Closes #4110
2026-11-18 16:34:49 +08:00
l0ng-ai aebd26bd7d feat(maven): setting to download dependency sources on import (#4182)
Settings › Build Tools › Maven › Automatically download sources maps to jdtls java.maven.downloadSources (previously always on in languages/java.toml). Off by default, as in IDEA's Maven › Importing: library classes open decompiled and the Download Sources banner fetches one library's sources on demand.

Closes #4097
2026-11-18 16:34:44 +08:00
l0ng-aiтаClaude c43a6169be ci: run only the jobs and smoke languages a pull request can affect (#4172)
CI's Changes job now decides each job on its own: Plugins on the plugin
workspaces, Cargo deny on manifests, the remote server build skips
desktop-, SDK- and test-only changes, Frontend skips backend-only changes
(a new Text catalog job runs the one test that reads Rust sources), and
E2E runs on the browser app's own sources.

Language smoke picks its matrix from the changed files: a language's
fixture, definition or JDT LS bundle runs that language, crates the
smoke doesn't exercise and crate tests run none. java/ now triggers it.

Co-authored-by: Claude <[email protected]>
2026-11-18 16:23:00 +08:00
LU XIANGRUIтаwildcatDownstairs c4836f6cd8 fix(viewers): Markdown preview follows File Types associations (#4139)
The Editor / Editor and Preview / Preview layouts were gated on a fixed extension list, while highlighting and LSP follow the language the backend detects from Settings › File Types. A file associated with Markdown (e.g. *.mmd) or overridden to Markdown now gets the preview, a file moved away from Markdown loses it, and open tabs update when File Types change. The check reuses hasFileType from #4144; the live-text contribution keys on the document's language.

Refs #4099

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 16:14:32 +08:00
l0ng-ai 02235cae04 test(heap): wait for the background cleanup in the stuck-capture shutdown test (#4169)
shutdown_within waits only briefly for the snapshot-directory cleanup and lets it finish in the background; on a busy CI runner the stuck-capture test asserted before it was done. The test now waits up to 10 s for the directory to go.
2026-11-18 16:14:09 +08:00
LU XIANGRUIтаwildcatDownstairs fcef18048a fix(web): HTML preview follows File Types associations (#4144)
The browser bar, Built-in Preview and Open in Browser were gated on a fixed extension list, and the built-in server chose Content-Type by extension, so a file associated with HTML in Settings › File Types (or via Override File Type) had no preview, and one moved away from HTML kept it. The frontend now decides with hasFileType (override, user patterns, then built-in extensions not removed — the order of LanguageRegistry::detect), open tabs update when File Types change, and web_url serves a file the backend detects as HTML as text/html (also fixes .shtml being served as application/octet-stream).

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-18 16:12:54 +08:00
Bin d72363b6ba fix(lsp): include workspace folder in ESLint configuration (#4145)
vscode-eslint resolves workingDirectory {mode: auto} from settings.workspaceFolder; without it the server falls back to the linted file's directory, so resolvers configured relative to the project (eslint-import-resolver-alias './src') looked under src/src and reported import/no-unresolved. The full workspace/configuration answer for eslint now carries the server root as workspaceFolder, as VS Code's client does. Other servers' answers are unchanged.

Closes #4143

Co-authored-by: ffgenius <[email protected]>
2026-11-18 16:11:18 +08:00
l0ng-ai 4ab4e0b44f fix(ci): use a Windows-absolute devshell path in the project environment test (#4149)
The project environment test's PATH entry /nix/store/x-devshell/bin has no drive letter on Windows, so the tool search path, which keeps absolute entries only, dropped it and the test failed there. The test uses C:\nix\store\x-devshell\bin on Windows.
2026-11-18 15:11:25 +08:00
l0ng-ai 43f7b6db25 chore: v0.1.48 2026-11-18 14:22:05 +08:00
l0ng-ai 92fd29707d fix(plugins): space marketplace detail notices from the header above 2026-11-18 14:15:40 +08:00
l0ng-ai 7482b27518 fix(run): a separate build linked inside another build's folder gets its own run configurations (#4134)
A Maven project or Gradle build linked explicitly got no run configurations when it sat inside the folder of another detected build without being one of its projects (a POM loaded with Load Maven Project below a root pom.xml that doesn't list it as a module, or a second linked Gradle build inside the root build's folder), so its main() fell back to Java Single File. A linked build is now left to the build around it only when that build's Maven reactor reaches it through <module>s (active profiles included) or its Gradle settings include it as a subproject. ide_build::maven::reactor_member_dirs lists a reactor's project folders from the memoized reactor walk.
2026-11-18 14:00:47 +08:00
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
507 змінених файлів з 14475 додано та 2278 видалено

No files matched your search

+65 -15
Переглянути файл
@@ -32,7 +32,12 @@ jobs:
pull-requests: read
outputs:
rust: ${{ steps.classify.outputs.rust }}
server: ${{ steps.classify.outputs.server }}
plugins: ${{ steps.classify.outputs.plugins }}
deny: ${{ steps.classify.outputs.deny }}
frontend: ${{ steps.classify.outputs.frontend }}
e2e: ${{ steps.classify.outputs.e2e }}
catalog: ${{ steps.classify.outputs.catalog }}
steps:
- id: classify
env:
@@ -40,26 +45,55 @@ jobs:
PR: ${{ github.event.pull_request.number }}
run: |
set -euo pipefail
jobs="rust server plugins deny frontend e2e catalog"
if [ "$GITHUB_EVENT_NAME" != pull_request ]; then
echo "rust=true" >> "$GITHUB_OUTPUT"
echo "frontend=true" >> "$GITHUB_OUTPUT"
for job in $jobs; do echo "$job=true" >> "$GITHUB_OUTPUT"; done
exit 0
fi
gh api --paginate "repos/$GITHUB_REPOSITORY/pulls/$PR/files" \
--jq '.[] | .filename, (.previous_filename // empty)' > files.txt
cat files.txt
# A change to CI itself runs everything.
ci='^\.github/(workflows/ci\.yml|actions/)'
docs='^(docs/|\.agents/|\.claude/|\.idea/|\.github/ISSUE_TEMPLATE/|\.github/pull_request_template\.md$|[^/]+\.md$|LICENSE$|NOTICE$)'
# Frontend-only paths. The Rust code embeds a few files under src/; those stay out.
web='^(src/|e2e/|perf/|public/|scripts/|smoke/|index\.html$|vite\.config\.ts$|tsconfig[^/]*\.json$|knip\.ts$|playwright\.config\.ts$|\.oxlintrc\.json$|\.oxfmtrc\.json$)'
web='^(src/|e2e/|perf/|public/|scripts/|smoke/|evals/|index\.html$|vite\.config\.ts$|tsconfig[^/]*\.json$|knip\.ts$|playwright\.config\.ts$|\.oxlintrc\.json$|\.oxfmtrc\.json$)'
embedded='^src/(bindings\.ts|styles/tokens\.css|features/plugins/views/frame-bridge\.js|platform/keymaps/)'
# A job runs when any changed file falls outside the paths that can't affect it.
rust=false
if grep -Ev "$docs|$web" files.txt | grep -q . || grep -Eq "$embedded" files.txt; then rust=true; fi
frontend=false
if grep -Ev "$docs" files.txt | grep -q .; then frontend=true; fi
echo "rust=$rust frontend=$frontend"
echo "rust=$rust" >> "$GITHUB_OUTPUT"
echo "frontend=$frontend" >> "$GITHUB_OUTPUT"
# Plugin web pages are their own pnpm projects, checked by the Plugins job only.
plugin_web='^plugins/official/[^/]+/web-src/'
# Paths the frontend checks never read...
backend='^(crates/|src-tauri/|sdk/|wit/|java/|fixtures/|Cargo\.(toml|lock)$|deny\.toml$|rustfmt\.toml$|rust-toolchain(\.toml)?$|\.cargo/)'
# ...except these, which frontend tests and e2e fixtures load.
read_by_web='^(fixtures/(folding|django-app)/|crates/ide-plugin/tests/fixtures/|crates/ide-db/(src|tests/fixtures)/snowflake/|src-tauri/(icons|capabilities)/|src-tauri/tauri\.conf\.json$)'
# What the browser app and its e2e tests are built from.
app='^(src/|e2e/|public/|index\.html$|vite\.config\.ts$|tsconfig\.json$|playwright\.config\.ts$|package\.json$|pnpm-(lock|workspace)\.yaml$|crates/ide-plugin/tests/fixtures/|src-tauri/(icons|capabilities)/|src-tauri/tauri\.conf\.json$)'
# The plugin workspaces: the SDK, the plugins, their interface and the host's fixture plugins.
plugin_ws='^(sdk/|plugins/|wit/|crates/ide-plugin/tests/fixtures/|rust-toolchain(\.toml)?$)'
# Never compiled into the openidea-server binary.
not_server='^(src-tauri/|sdk/|fixtures/|crates/[^/]+/(tests|benches)/)'
deps='(^|/)Cargo\.(toml|lock)$|^deny\.toml$'
# The text catalog test reads the string literals of every Rust source.
rust_source='^(crates|src-tauri/src)/.*\.rs$'
any() { grep -Eq "$1" files.txt; }
outside() { [ -n "$(grep -Ev "$1" files.txt || true)" ]; }
set_job() { echo "$1=$2" | tee -a "$GITHUB_OUTPUT"; }
if any "$ci"; then
for job in $jobs; do set_job "$job" true; done
exit 0
fi
on() { if "${@:2}"; then set_job "$1" true; else set_job "$1" false; fi; }
rust_build() { outside "$1" || any "$embedded"; }
web_checks() { outside "$docs|$plugin_web|$backend" || any "$read_by_web"; }
catalog_only() { ! web_checks && any "$rust_source"; }
on rust rust_build "$docs|$web|$plugin_web"
on server rust_build "$docs|$web|$plugin_web|$not_server"
on plugins any "$plugin_ws"
on deny any "$deps"
on frontend web_checks
on e2e any "$app"
on catalog catalog_only
rust:
name: Rust (${{ matrix.os }})
@@ -111,7 +145,7 @@ jobs:
server:
name: Remote server (linux musl)
needs: changes
if: needs.changes.outputs.rust == 'true'
if: needs.changes.outputs.server == 'true'
timeout-minutes: 40
runs-on: ubuntu-22.04
steps:
@@ -129,7 +163,7 @@ jobs:
plugins:
name: Plugins (SDK, official, fixtures)
needs: changes
if: needs.changes.outputs.rust == 'true'
if: needs.changes.outputs.plugins == 'true'
timeout-minutes: 30
runs-on: ubuntu-22.04
env:
@@ -181,7 +215,7 @@ jobs:
deny:
name: Cargo deny
needs: changes
if: needs.changes.outputs.rust == 'true'
if: needs.changes.outputs.deny == 'true'
timeout-minutes: 15
runs-on: ubuntu-latest
steps:
@@ -210,10 +244,26 @@ jobs:
- run: pnpm test
- run: pnpm build
# A backend-only change can still drop a string the text catalog uses: run that one test.
catalog:
name: Text catalog
needs: changes
if: needs.changes.outputs.catalog == 'true'
timeout-minutes: 15
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v5
- uses: pnpm/action-setup@v5
with: { version: 11 }
- uses: actions/setup-node@v5
with: { node-version: 22, cache: pnpm }
- run: pnpm install --frozen-lockfile
- run: pnpm vitest run src/platform/locales/textCatalog.test.ts
e2e:
name: E2E (${{ matrix.shard }}/2)
needs: changes
if: needs.changes.outputs.frontend == 'true'
if: needs.changes.outputs.e2e == 'true'
timeout-minutes: 30
runs-on: ubuntu-24.04
strategy:
+67 -1
Переглянути файл
@@ -15,6 +15,7 @@ on:
- "crates/**"
- "languages/**"
- "fixtures/**"
- "java/**"
- "Cargo.toml"
- "Cargo.lock"
- "src/features/run/**"
@@ -41,12 +42,77 @@ env:
CARGO_INCREMENTAL: 0
jobs:
# The languages a pull request can affect: a change to one language's fixture, definition or
# JDT LS bundle runs that language; crates the smoke doesn't exercise and other crates' tests
# run none; anything else runs them all. Pushes and manual runs always run them all.
changes:
name: Changes
runs-on: ubuntu-latest
timeout-minutes: 5
permissions:
pull-requests: read
outputs:
languages: ${{ steps.classify.outputs.languages }}
steps:
- id: classify
env:
GH_TOKEN: ${{ github.token }}
PR: ${{ github.event.pull_request.number }}
run: |
set -euo pipefail
all="typescript python rust go java kotlin php c cpp"
emit() { tr ' ' '\n' <<< "$1" | { grep . || true; } | sort -u | jq -Rsc 'split("\n") | map(select(. != ""))'; }
if [ "$GITHUB_EVENT_NAME" != pull_request ]; then
echo "languages=$(emit "$all")" | tee -a "$GITHUB_OUTPUT"
exit 0
fi
gh api --paginate "repos/$GITHUB_REPOSITORY/pulls/$PR/files" \
--jq '.[] | .filename, (.previous_filename // empty)' > files.txt
cat files.txt
# Crates outside what the smoke runs (language servers, debuggers, run configurations,
# SDKs, build tools and the project model): cargo metadata, deps of ide-lsp/dap/run/sdk/tools.
unused='^crates/(ide-agent|ide-analysis|ide-android|ide-cli|ide-clipboard|ide-coverage|ide-db|ide-docker|ide-fonts|ide-github|ide-http|ide-mcp|ide-notebook|ide-profiler|ide-scaffold|ide-search|ide-spell|ide-ssh|ide-streams|ide-vcs|ide-web)/'
# The workflow's paths, less those handled per language below.
smoke='^(crates/|Cargo\.(toml|lock)$|src/features/(run|debugger)/|src/platform/|smoke/|package\.json$|pnpm-lock\.yaml$|\.github/workflows/language-smoke\.yml$|\.github/tool-versions\.env$)'
langs=""
while read -r f; do
case "$f" in
crates/ide-host/tests/language_smoke.rs | crates/ide-host/tests/project_smoke.rs) langs="$all"; break ;;
crates/*/tests/* | crates/*/benches/*) ;;
fixtures/ts-app/*) langs+=" typescript" ;;
fixtures/python-app/*) langs+=" python" ;;
fixtures/rust-app/*) langs+=" rust" ;;
fixtures/go-app/*) langs+=" go" ;;
fixtures/java-app/*) langs+=" java" ;;
fixtures/kotlin-gradle/*) langs+=" kotlin" ;;
fixtures/php-app/*) langs+=" php" ;;
fixtures/c-app/*) langs+=" c cpp" ;;
fixtures/*) ;;
languages/typescript.toml | languages/typescriptreact.toml | languages/javascript.toml | languages/javascriptreact.toml) langs+=" typescript" ;;
languages/python.toml) langs+=" python" ;;
languages/rust.toml) langs+=" rust" ;;
languages/go.toml | languages/gomod.toml | languages/gowork.toml) langs+=" go" ;;
languages/java.toml) langs+=" java" ;;
languages/kotlin.toml) langs+=" kotlin" ;;
languages/php.toml) langs+=" php" ;;
languages/c.toml) langs+=" c" ;;
languages/cpp.toml) langs+=" cpp" ;;
languages/*) ;;
java/kotlin-bridge/*) langs+=" kotlin" ;;
java/*) langs+=" java kotlin" ;;
*) if grep -Eq "$smoke" <<< "$f" && ! grep -Eq "$unused" <<< "$f"; then langs="$all"; break; fi ;;
esac
done < files.txt
echo "languages=$(emit "$langs")" | tee -a "$GITHUB_OUTPUT"
smoke:
name: Language smoke (${{ matrix.language }})
needs: changes
if: needs.changes.outputs.languages != '[]'
strategy:
fail-fast: false
matrix:
language: [typescript, python, rust, go, java, kotlin, php, c, cpp]
language: ${{ fromJSON(needs.changes.outputs.languages) }}
# C/C++ debug with GDB, whose DAP interpreter needs 14+: 22.04 ships 12.1, 24.04 ships 15.
runs-on: ${{ (matrix.language == 'c' || matrix.language == 'cpp') && 'ubuntu-24.04' || 'ubuntu-22.04' }}
timeout-minutes: 40
Створено
+46 -46
Переглянути файл
@@ -4144,7 +4144,7 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
[[package]]
name = "ide-agent"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"blake3",
"dunce",
@@ -4169,7 +4169,7 @@ dependencies = [
[[package]]
name = "ide-analysis"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"ast-grep-core",
"ide-core",
@@ -4183,7 +4183,7 @@ dependencies = [
[[package]]
name = "ide-android"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"ide-core",
"serde",
@@ -4194,7 +4194,7 @@ dependencies = [
[[package]]
name = "ide-build"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"blake3",
"chardetng",
@@ -4212,7 +4212,7 @@ dependencies = [
[[package]]
name = "ide-cli"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"dirs 6.0.0",
"serde",
@@ -4226,7 +4226,7 @@ dependencies = [
[[package]]
name = "ide-clipboard"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"gtk",
"objc2 0.6.5",
@@ -4237,7 +4237,7 @@ dependencies = [
[[package]]
name = "ide-command"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"heck 0.5.0",
"proc-macro2",
@@ -4248,7 +4248,7 @@ dependencies = [
[[package]]
name = "ide-core"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"dunce",
"encoding_rs",
@@ -4265,7 +4265,7 @@ dependencies = [
[[package]]
name = "ide-coverage"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"ide-core",
"ide-run",
@@ -4279,7 +4279,7 @@ dependencies = [
[[package]]
name = "ide-dap"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"base64 0.22.1",
"futures",
@@ -4308,7 +4308,7 @@ dependencies = [
[[package]]
name = "ide-db"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"base64 0.22.1",
"bb8",
@@ -4344,7 +4344,7 @@ dependencies = [
[[package]]
name = "ide-docker"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"ide-core",
"serde",
@@ -4357,7 +4357,7 @@ dependencies = [
[[package]]
name = "ide-extension"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4378,7 +4378,7 @@ dependencies = [
[[package]]
name = "ide-fonts"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"objc2-core-foundation",
"objc2-core-text",
@@ -4390,7 +4390,7 @@ dependencies = [
[[package]]
name = "ide-github"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"ide-core",
"ide-vcs",
@@ -4403,7 +4403,7 @@ dependencies = [
[[package]]
name = "ide-heap"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"criterion",
"ide-core",
@@ -4421,7 +4421,7 @@ dependencies = [
[[package]]
name = "ide-host"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4495,7 +4495,7 @@ dependencies = [
[[package]]
name = "ide-http"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"ide-core",
"ide-vfs",
@@ -4514,7 +4514,7 @@ dependencies = [
[[package]]
name = "ide-index"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"blake3",
"criterion",
@@ -4536,7 +4536,7 @@ dependencies = [
[[package]]
name = "ide-jdwp"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"ide-jvm-inspect",
"proptest",
@@ -4548,7 +4548,7 @@ dependencies = [
[[package]]
name = "ide-jsonrpc"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"encoding_rs",
"futures",
@@ -4565,7 +4565,7 @@ dependencies = [
[[package]]
name = "ide-jvm-attach"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"libc",
"tempfile",
@@ -4574,7 +4574,7 @@ dependencies = [
[[package]]
name = "ide-jvm-inspect"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"futures",
"serde",
@@ -4585,7 +4585,7 @@ dependencies = [
[[package]]
name = "ide-language"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"blake3",
"criterion",
@@ -4644,7 +4644,7 @@ dependencies = [
[[package]]
name = "ide-lsp"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"dunce",
"encoding_rs",
@@ -4672,7 +4672,7 @@ dependencies = [
[[package]]
name = "ide-mcp"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"bytes",
"dunce",
@@ -4691,7 +4691,7 @@ dependencies = [
[[package]]
name = "ide-notebook"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"futures",
"ide-core",
@@ -4714,7 +4714,7 @@ dependencies = [
[[package]]
name = "ide-plugin"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"blake3",
"dunce",
@@ -4737,7 +4737,7 @@ dependencies = [
[[package]]
name = "ide-profiler"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"ide-core",
"ide-jvm-attach",
@@ -4751,7 +4751,7 @@ dependencies = [
[[package]]
name = "ide-remote"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"dunce",
"futures",
@@ -4771,7 +4771,7 @@ dependencies = [
[[package]]
name = "ide-run"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"dunce",
"encoding_rs",
@@ -4795,7 +4795,7 @@ dependencies = [
[[package]]
name = "ide-scaffold"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"ide-core",
"ide-tools",
@@ -4811,7 +4811,7 @@ dependencies = [
[[package]]
name = "ide-sdk"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"dunce",
"flate2",
@@ -4834,7 +4834,7 @@ dependencies = [
[[package]]
name = "ide-search"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"criterion",
"encoding_rs",
@@ -4855,7 +4855,7 @@ dependencies = [
[[package]]
name = "ide-spell"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"ide-core",
"parking_lot",
@@ -4868,7 +4868,7 @@ dependencies = [
[[package]]
name = "ide-ssh"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"dirs 6.0.0",
"flate2",
@@ -4893,7 +4893,7 @@ dependencies = [
[[package]]
name = "ide-streams"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"ide-core",
"ide-language",
@@ -4906,7 +4906,7 @@ dependencies = [
[[package]]
name = "ide-syntax"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"ide-core",
"ide-language",
@@ -4921,7 +4921,7 @@ dependencies = [
[[package]]
name = "ide-terminal"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"ide-core",
"libc",
@@ -4934,7 +4934,7 @@ dependencies = [
[[package]]
name = "ide-text"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"criterion",
"ide-core",
@@ -4947,7 +4947,7 @@ dependencies = [
[[package]]
name = "ide-tools"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"flate2",
"hex",
@@ -4968,7 +4968,7 @@ dependencies = [
[[package]]
name = "ide-vcs"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"blake3",
"dunce",
@@ -4989,7 +4989,7 @@ dependencies = [
[[package]]
name = "ide-vfs"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"chardetng",
"dunce",
@@ -5015,7 +5015,7 @@ dependencies = [
[[package]]
name = "ide-web"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"dirs 6.0.0",
"ide-core",
@@ -5031,7 +5031,7 @@ dependencies = [
[[package]]
name = "ide-workspace"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"blake3",
"dunce",
@@ -6660,7 +6660,7 @@ dependencies = [
[[package]]
name = "openidea"
version = "0.1.47"
version = "0.1.48"
dependencies = [
"base64 0.22.1",
"blake3",
+1 -1
Переглянути файл
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
exclude = ["sdk", "plugins"]
[workspace.package]
version = "0.1.47"
version = "0.1.48"
edition = "2024"
rust-version = "1.96"
license = "Apache-2.0"
+30
Переглянути файл
@@ -194,6 +194,36 @@ declarations, key and animation binding names (`(keydown.enter)`, `[@fade]`,
`(@fade.done)`), runs of text that entities split (`a && b`) parsed as one, and one
token for `{` and `}`.
## Julia CodeMirror language support
[`@plutojl/lang-julia`](https://github.com/JuliaPluto/lang-julia) 1.2.0 and its
[`@plutojl/lezer-julia`](https://github.com/JuliaPluto/lezer-julia) parser dependency
provide the Julia CodeMirror 6 language mode. Both packages are MIT licensed;
the full license text is below. The mode wraps a Lezer grammar and exposes its
syntax tags through `julia()`.
### MIT License (@plutojl/lang-julia and @plutojl/lezer-julia)
Copyright (c) 2021 Andrey Popp
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
## nvim-treesitter queries
`crates/ide-syntax/queries/<grammar>/locals.scm` are derived from the `locals.scm`
+25
Переглянути файл
@@ -213,6 +213,31 @@ impl AgentCatalogs {
.unwrap_or_else(|| Self::fallback(shared, provider))
}
/// Availability for an explicit session switch must come from a recent discovery for this
/// launch, not from the display fallback or a different project's session report.
pub(super) fn fresh_model(
&self,
shared: &Shared,
spec: &provider::ProviderSpec,
model: &str,
) -> Option<crate::AgentConfigValue> {
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
let select = |catalog: &CatalogData| {
let age = self.epoch_ms() - catalog.refreshed_at_ms?;
if !(0.0..FRESH_FOR.as_millis() as f64).contains(&age) {
return None;
}
catalog.model_option()?.values.iter().find(|value| value.value == model).cloned()
};
let state = self.state.lock();
if let Some(entry) = state.entries.get(&Self::key(shared, &spec.id)) {
return select(entry.catalog.as_ref().filter(|_| entry.context == context)?);
}
let cache = shared.known.lock();
let saved = cache.get(&spec.id)?.catalogs.get(&shared.root_key())?;
(saved.fingerprint == context.fingerprint()).then(|| select(&saved.catalog)).flatten()
}
pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option<Vec<AgentConfigOption>> {
let state = self.state.lock();
if let Some(catalog) = state.entries.get(&Self::key(shared, provider)).and_then(|entry| entry.catalog.as_ref())
+227 -2
Переглянути файл
@@ -11,6 +11,7 @@ const PROVIDER: &str = "catalog-test";
#[derive(Debug)]
struct Pending {
launch: usize,
method: String,
params: Value,
reply: oneshot::Sender<Result<Value, String>>,
@@ -44,7 +45,7 @@ impl Harness {
let launches = launches.clone();
let live = live.clone();
move |_, _, client, _| {
launches.fetch_add(1, Ordering::SeqCst);
let launch = launches.fetch_add(1, Ordering::SeqCst);
live.fetch_add(1, Ordering::SeqCst);
let guard = Live(live.clone());
let pending = pending_tx.clone();
@@ -75,10 +76,17 @@ impl Harness {
}
let response = match request["method"].as_str().unwrap() {
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": initialize }),
"session/new" | "session/set_config_option" | "session/set_model" => {
"session/new"
| "session/set_config_option"
| "session/set_model"
| "session/load"
| "session/resume"
| "session/prompt"
| "session/set_mode" => {
let (reply, mut result) = oneshot::channel();
pending
.send(Pending {
launch,
method: request["method"].as_str().unwrap().to_owned(),
params: request["params"].clone(),
reply,
@@ -290,6 +298,223 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
assert_eq!(efforts(&fresh, "second"), ["off", "auto"]);
}
#[tokio::test]
async fn discovered_model_is_confirmed_by_the_live_session() {
switch_chat_model(ChatSwitch::Live).await;
}
#[tokio::test]
async fn discovered_model_reloads_the_same_session_on_the_next_message() {
switch_chat_model(ChatSwitch::Resume).await;
}
#[tokio::test]
async fn discovered_model_leaves_the_original_session_intact_after_resume_failure() {
switch_chat_model(ChatSwitch::ResumeFails).await;
}
#[tokio::test]
async fn discovered_model_is_reverted_when_the_reloaded_session_does_not_offer_it() {
switch_chat_model(ChatSwitch::Unavailable).await;
}
#[tokio::test]
async fn discovered_model_can_be_selected_while_the_session_is_not_running() {
switch_chat_model(ChatSwitch::Idle).await;
}
#[derive(Clone, Copy)]
enum ChatSwitch {
Live,
Resume,
ResumeFails,
Unavailable,
Idle,
}
async fn switch_chat_model(scenario: ChatSwitch) {
use crate::{AgentPrompt, AgentStatus, Isolation, NewAgentTask};
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::with_initialize(json!({
"protocolVersion": 1, "agentCapabilities": { "loadSession": true }
}));
let mut manager = make_manager(tmp.path(), Arc::default(), &harness);
let task = manager
.create(NewAgentTask {
prompt: AgentPrompt { text: "first".into(), ..Default::default() },
provider: PROVIDER.into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
let next = harness.next().await;
assert_eq!((next.launch, next.method.as_str()), (0, "session/new"));
let mut initial = response(&["old"], &["low", "high"]);
initial["sessionId"] = json!("saved-chat");
initial["modes"] = json!({
"currentModeId": "code", "availableModes": [{"id": "ask", "name": "Ask"}, {"id": "code", "name": "Code"}]
});
next.reply.send(Ok(initial.clone())).unwrap();
let next = harness.next().await;
assert_eq!(
(next.launch, next.method.as_str(), &next.params["sessionId"]),
(0, "session/prompt", &json!("saved-chat"))
);
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
{
let mode = manager.set_config(&task.id, "mode", "ask".into());
tokio::pin!(mode);
let set = next_chat_request(&mut harness, mode.as_mut()).await;
assert_eq!((set.launch, set.method.as_str()), (0, "session/set_mode"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
set.reply.send(Ok(json!({}))).unwrap();
mode.await.unwrap();
}
let before_entries = serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap();
let before_config = manager.task(&task.id).unwrap().state.lock().task.config.clone();
if matches!(scenario, ChatSwitch::Idle) {
manager.shutdown();
manager = make_manager(tmp.path(), Arc::default(), &harness);
}
let mut events = events(&manager);
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
let next = harness.next().await;
assert_eq!((next.launch, next.method.as_str()), (1, "session/new"));
next.reply.send(Ok(response(&["new", "old"], &["catalog-only"]))).unwrap();
assert_eq!(model_values(&completed(&mut events).await), ["new", "old"]);
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
let live = matches!(scenario, ChatSwitch::Live);
let offline = matches!(scenario, ChatSwitch::Idle);
let load_fails = matches!(scenario, ChatSwitch::ResumeFails);
let unavailable = matches!(scenario, ChatSwitch::Unavailable);
let switching = manager.set_config(&task.id, "model", "new".into());
tokio::pin!(switching);
if !offline {
let next = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
if live {
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
} else {
next.reply.send(Err("not in this process's model list".into())).unwrap();
}
}
// A fallback selection settles without waiting for a new process.
tokio::select! {
result = &mut switching => result.unwrap(),
request = harness.next() => panic!("selection must not open another session: {request:?}"),
}
assert_eq!(serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap(), before_entries);
let snapshot = |manager: &AgentManager| manager.subscribe(Arc::new(|_| {})).remove(0);
let current = snapshot(&manager);
assert_eq!(current.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("new"));
assert_eq!(current.model.as_deref(), Some(if live { "new" } else { "old" }));
manager.prompt(&task.id, AgentPrompt { text: "next".into(), ..Default::default() }, false).await.unwrap();
if !live {
let load = harness.next().await;
assert_eq!((load.launch, load.method.as_str()), (2, "session/load"));
assert_eq!(load.params["sessionId"], "saved-chat");
load.notifications
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
"sessionId": "saved-chat",
"update": {"sessionUpdate": "agent_message_chunk", "content": {"type": "text", "text": "replay"}}
}}))
.unwrap();
if load_fails {
load.notifications
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
"sessionId": "saved-chat",
"update": {"sessionUpdate": "config_option_update",
"configOptions": response(&["other", "old"], &["low"])["configOptions"]}
}}))
.unwrap();
load.reply.send(Err("cannot resume saved-chat".into())).unwrap();
} else {
let models: &[&str] = if unavailable { &["old"] } else { &["old", "new"] };
let mut resumed = response(models, &["low", "high"]);
resumed["modes"] = initial["modes"].clone();
load.reply.send(Ok(resumed)).unwrap();
}
if load_fails || unavailable {
wait_for_chat(&manager, &task.id, AgentStatus::Failed).await;
let task = snapshot(&manager);
assert_eq!(task.model.as_deref(), Some("old"));
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
let expected = if load_fails { "cannot resume saved-chat" } else { "does not offer model new" };
assert!(task.error.as_deref().unwrap().contains(expected), "{:?}", task.error);
assert!(harness.pending.try_recv().is_err(), "must not send on the previous model or create a session");
if load_fails {
manager
.prompt(&task.id, AgentPrompt { text: "retry".into(), ..Default::default() }, false)
.await
.unwrap();
let retry = harness.next().await;
assert_eq!((retry.launch, retry.method.as_str()), (3, "session/load"));
assert_eq!(retry.params["sessionId"], "saved-chat");
retry.reply.send(Ok(initial.clone())).unwrap();
let set = harness.next().await;
assert_eq!(set.method, "session/set_mode");
set.reply.send(Ok(json!({}))).unwrap();
let prompt = harness.next().await;
assert_eq!(prompt.method, "session/prompt");
assert_eq!(prompt.params["sessionId"], "saved-chat");
prompt.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
}
manager.shutdown();
return;
}
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_config_option"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
set.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_mode"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
set.reply.send(Ok(json!({}))).unwrap();
}
let next = harness.next().await;
assert_eq!(
(next.launch, next.method.as_str(), &next.params["sessionId"]),
(if live { 0 } else { 2 }, "session/prompt", &json!("saved-chat"))
);
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
let current = snapshot(&manager);
assert_eq!(current.model.as_deref(), Some("new"));
assert_eq!(current.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("session-only"));
assert_eq!(current.config.iter().find(|o| o.id == "mode").unwrap().current.as_deref(), Some("ask"));
manager.shutdown();
}
async fn wait_for_chat(manager: &AgentManager, id: &str, status: crate::AgentStatus) {
let task = manager.task(id).unwrap();
tokio::time::timeout(Duration::from_secs(5), async {
while task.state.lock().task.status != status || task.state.lock().busy {
tokio::task::yield_now().await;
}
})
.await
.unwrap();
}
async fn next_chat_request(
harness: &mut Harness,
switching: std::pin::Pin<&mut impl Future<Output = crate::IdeResult<()>>>,
) -> Pending {
tokio::select! {
result = switching => panic!("model switching ended before contacting the session: {result:?}"),
request = harness.next() => request,
}
}
#[tokio::test]
async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
let tmp = tempfile::tempdir().unwrap();
+17
Переглянути файл
@@ -219,6 +219,23 @@ pub(crate) fn set_request(option: &AgentConfigOption, value: &str) -> (&'static
}
}
/// Legacy setters and agents that report the change in a notification may return no model.
pub(super) fn accepts_model(reply: &Value, id: &str, value: &str) -> bool {
reply
.get("configOptions")
.and_then(Value::as_array)
.and_then(|options| {
options.iter().find(|option| {
option.get("category").and_then(Value::as_str) == Some("model")
|| option.get("id").or_else(|| option.get("configId")).and_then(Value::as_str) == Some(id)
})
})
.and_then(|option| option.get("currentValue"))
.or_else(|| reply.pointer("/models/currentModelId"))
.and_then(Value::as_str)
.is_none_or(|current| current == value)
}
/// `available_commands_update`.
pub(crate) fn commands_of(update: &Value, provider: &str) -> Vec<AgentCommand> {
update
+370 -59
Переглянути файл
@@ -348,6 +348,9 @@ struct TaskFile {
/// Settings the user chose, re-applied to every new or reloaded session.
#[serde(default)]
wanted: Vec<AgentConfigChoice>,
/// Option id of a discovered model in `wanted` that still needs a same-session reload.
#[serde(default, skip_serializing_if = "Option::is_none")]
pending_model: Option<String>,
/// In the project's own checkout: files already changed when the task started.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
before: BTreeMap<String, worktree::Stamp>,
@@ -359,6 +362,9 @@ struct TaskFile {
/// `None` for a worktree task, and a task saved before these were recorded.
#[serde(default, skip_serializing_if = "Option::is_none")]
touched: Option<BTreeSet<String>>,
/// The checkout as the last turn started, its copies in the store's `<id>.turn` folder.
#[serde(default, skip_serializing_if = "Option::is_none")]
turn: Option<worktree::TurnStart>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
subagents: Vec<SavedSubagent>,
/// Turns to drop from the session once it is loaded (a fork of an earlier point).
@@ -377,11 +383,14 @@ struct TaskState {
session_id: Option<String>,
conversation: Conversation,
wanted: Vec<AgentConfigChoice>,
pending_model: Option<String>,
model_choice: u64,
before: Arc<BTreeMap<String, worktree::Stamp>>,
saved: Option<String>,
/// See `TaskFile::touched`.
touched: Option<Arc<BTreeSet<String>>>,
/// See `TaskFile::turn`.
turn: Option<Arc<worktree::TurnStart>>,
pending_rollback: u32,
/// The user named the task; see `TaskFile::title_renamed`.
title_renamed: bool,
@@ -393,6 +402,24 @@ struct TaskState {
background_tasks: Vec<Value>,
}
impl TaskState {
fn pending_model(&self) -> Option<&AgentConfigChoice> {
let id = self.pending_model.as_deref()?;
self.wanted.iter().find(|c| c.id == id)
}
fn snapshot(&self) -> AgentTask {
let mut task = self.task.clone();
if let Some(choice) = self.pending_model()
&& let Some(model) = task.config.iter_mut().find(|o| o.id == choice.id)
{
model.current = Some(choice.value.clone());
task.config.retain(|o| !config::is_per_model_option(o));
}
task
}
}
/// A running agent and its session.
#[derive(Clone)]
struct Live {
@@ -519,7 +546,7 @@ impl AgentManager {
/// Routes events to `sink` (replacing the previous subscriber); returns every task.
pub fn subscribe(&self, sink: AgentSink) -> Vec<AgentTask> {
*self.shared.sink.write() = Some(sink);
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().task.clone()).collect();
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().snapshot()).collect();
tasks.sort_by(|a, b| b.updated_ms.total_cmp(&a.updated_ms));
tasks
}
@@ -750,9 +777,11 @@ impl AgentManager {
session_id: Some(session_id.to_owned()),
entries: Vec::new(),
wanted: Vec::new(),
pending_model: None,
before: BTreeMap::new(),
saved: None,
touched: Some(BTreeSet::new()),
turn: None,
subagents: Vec::new(),
pending_rollback: 0,
title_renamed: true,
@@ -863,9 +892,11 @@ impl AgentManager {
session_id: None,
entries: Vec::new(),
wanted: req.config,
pending_model: None,
before,
saved,
touched: (req.isolation == Isolation::Local).then(BTreeSet::new),
turn: None,
subagents: Vec::new(),
pending_rollback: 0,
title_renamed: false,
@@ -994,7 +1025,7 @@ impl AgentManager {
/// Changes a session setting (model, mode…): right away when the agent runs, else when it next starts.
pub async fn set_config(&self, id: &str, option: &str, value: String) -> IdeResult<()> {
let task = self.task(id)?;
let (target, model_choice, previous_levels) = {
let (target, change) = {
let mut s = task.state.lock();
let target = s
.task
@@ -1004,22 +1035,28 @@ impl AgentManager {
.ok_or_else(|| IdeError::not_found("no such setting"))?
.clone();
if !target.values.iter().any(|v| v.value == value) {
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
if target.category.as_deref() != Some("model") {
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
}
(target, None)
} else {
let switching_model = target.category.as_deref() == Some("model");
if switching_model {
s.model_choice += 1;
s.pending_model = None;
}
let previous_levels = (switching_model && target.current.as_deref() != Some(value.as_str()))
.then(|| s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>());
s.wanted.retain(|c| c.id != option);
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() });
s.task.config.iter_mut().find(|o| o.id == option).expect("selected setting").current =
Some(value.clone());
s.task.model = model_of(&s.task.config).or(s.task.model.take());
(target, Some((s.model_choice, previous_levels)))
}
if target.category.as_deref() == Some("model") {
s.model_choice += 1;
}
let previous_levels =
if target.category.as_deref() == Some("model") && target.current.as_deref() != Some(value.as_str()) {
Some(s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>())
} else {
None
};
s.wanted.retain(|c| c.id != option);
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() });
s.task.config.iter_mut().find(|o| o.id == option).expect("selected setting").current = Some(value.clone());
s.task.model = model_of(&s.task.config).or(s.task.model.take());
(target, s.model_choice, previous_levels)
};
let Some((model_choice, previous_levels)) = change else {
return task.switch_discovered_model(target, value).await;
};
let previous = target.current.clone();
// Cursor's `session/set_config_option` (Fast, effort) can take seconds. Show the
@@ -1186,9 +1223,12 @@ impl AgentManager {
session_id: Some(session),
entries,
wanted: s.wanted.clone(),
pending_model: None,
before: (*s.before).clone(),
saved: s.saved.clone(),
touched: s.touched.as_deref().cloned(),
// The source's next turn replaces its copies: the fork's last turn is one of its own.
turn: None,
subagents: s.conversation.saved_subagents(),
pending_rollback: total - keep,
title_renamed: s.title_renamed,
@@ -1228,6 +1268,7 @@ impl AgentManager {
_ => None,
};
s.session_id = None;
s.pending_model = None;
s.conversation = Conversation::default();
// The fresh session reports its own usage; nothing carries over.
s.task.usage = None;
@@ -1528,6 +1569,7 @@ impl AgentManager {
self.tasks.write().remove(id);
*task.deleted.lock() = true;
let _ = std::fs::remove_file(self.shared.paths.store_dir.join(format!("{id}.json")));
let _ = std::fs::remove_dir_all(task.turn_dir());
let saved = task.state.lock().saved.clone();
if let Some(saved) = saved
&& !self.tasks.read().values().any(|t| t.state.lock().saved.as_ref() == Some(&saved))
@@ -1570,18 +1612,47 @@ impl AgentManager {
.await
}
/// Content of `path` (in the task's directory) when the task started.
pub async fn base_text(&self, id: &str, path: PathBuf) -> IdeResult<Option<String>> {
let at = self.task(id)?.base();
blocking(move || match at.rev()? {
Some(rev) => worktree::file_at(at.cwd(), &path, &rev),
None => Ok(None),
/// The files the task's last turn changed, against the checkout as it started (while a
/// turn runs: that turn's so far). None before the task's first turn.
pub async fn turn_changes(&self, id: &str) -> IdeResult<Vec<AgentChange>> {
let (cwd, turn, dir) = self.task(id)?.last_turn();
let Some(turn) = turn else { return Ok(Vec::new()) };
blocking(move || {
let changed = match &turn.changed {
Some(changed) => changed.clone(),
None => worktree::changed_in_turn(&cwd, &turn)?.1,
};
worktree::turn_changes(&cwd, &turn, &dir, &changed)
})
.await
}
/// Content of `path` (in the task's directory) as `view` compares it: when the task
/// started, in `HEAD`, or when the last turn started.
pub async fn base_text(&self, id: &str, path: PathBuf, view: AgentChangesView) -> IdeResult<Option<String>> {
let task = self.task(id)?;
if view == AgentChangesView::LastTurn {
let (cwd, turn, dir) = task.last_turn();
let Some(turn) = turn else { return Ok(None) };
return blocking(move || worktree::turn_text(&cwd, &path, &turn, &dir)).await;
}
let at = task.base();
blocking(move || {
let rev = match view {
AgentChangesView::Group => worktree::head_commit(at.cwd())?,
_ => at.rev()?,
};
match rev {
Some(rev) => worktree::file_at(at.cwd(), &path, &rev),
None => Ok(None),
}
})
.await
}
/// Rollback: puts the task's changed files among `rel_paths` (all with `None`) back as
/// `view` compares them: as they were when it started, or as they are in `HEAD`.
/// `view` compares them: as they were when it started, as they are in `HEAD`, or as they
/// were when its last turn started.
pub async fn rollback_changes(
&self,
id: &str,
@@ -1592,15 +1663,18 @@ impl AgentManager {
if task.state.lock().busy {
return Err(IdeError::invalid("the agent is working: stop it before rolling back its changes"));
}
if view == AgentChangesView::LastTurn {
return self.rollback_turn(&task, rel_paths).await;
}
let at = task.base();
let (before, saved, touched) = {
let s = task.state.lock();
(s.before.clone(), s.saved.as_ref().map(|name| self.shared.paths.store_dir.join(name)), s.touched.clone())
};
let restamped = blocking(move || {
let (restamped, restored) = blocking(move || {
let (changes, rev) = match view {
AgentChangesView::Group => (at.grouped_changes(&before)?.uncommitted, worktree::head_commit(at.cwd())?),
AgentChangesView::SinceStart => (at.changes(&before)?, at.rev()?),
AgentChangesView::SinceStart | AgentChangesView::LastTurn => (at.changes(&before)?, at.rev()?),
};
let changes = worktree::made_by_task(changes, touched.as_deref());
let sources = match rev.as_deref() {
@@ -1608,6 +1682,7 @@ impl AgentManager {
None => Default::default(),
};
let mut restamped = Vec::new();
let mut restored = Vec::new();
for change in changes.iter().filter(|c| rel_paths.as_ref().is_none_or(|p| p.contains(&c.rel_path))) {
// A rename goes back to its old path too; the new one is taken away first, so a
// case-only rename on a case-insensitive disk ends as the old file.
@@ -1617,6 +1692,58 @@ impl AgentManager {
if before.contains_key(&change.rel_path) {
restamped.push((change.rel_path.clone(), worktree::stamp(&change.path.0)));
}
restored.push(change.rel_path.clone());
}
}
Ok((restamped, restored))
})
.await?;
{
let mut s = task.state.lock();
if !restamped.is_empty() {
let mut before = (*s.before).clone();
before.extend(restamped);
s.before = Arc::new(before);
}
// Rolled back further than the last turn: what it changed there is gone, not the turn's to list.
if let Some(turn) = &s.turn
&& let Some(changed) = &turn.changed
&& restored.iter().any(|rel| changed.contains(rel))
{
let changed = changed.iter().filter(|rel| !restored.contains(rel)).cloned().collect();
s.turn = Some(Arc::new(worktree::TurnStart { changed: Some(changed), ..(**turn).clone() }));
}
}
task.persist();
Ok(())
}
/// Puts the last turn's changed files among `rel_paths` (all with `None`) back as they
/// were when it started.
async fn rollback_turn(&self, task: &Task, rel_paths: Option<Vec<String>>) -> IdeResult<()> {
let (cwd, turn, dir) = task.last_turn();
let Some(turn) = turn else { return Ok(()) };
let (before, saved) = {
let s = task.state.lock();
(s.before.clone(), s.saved.as_ref().map(|name| self.shared.paths.store_dir.join(name)))
};
let restamped = blocking(move || {
let changed = match &turn.changed {
Some(changed) => changed.clone(),
None => worktree::changed_in_turn(&cwd, &turn)?.1,
};
let mut restamped = Vec::new();
for change in worktree::turn_changes(&cwd, &turn, &dir, &changed)?
.iter()
.filter(|c| rel_paths.as_ref().is_none_or(|p| p.contains(&c.rel_path)))
{
worktree::restore_turn(&cwd, &turn, &dir, change)?;
// Back to the user's own edits from before the task: not a change of the task.
if let Some(Some(_)) = before.get(&change.rel_path)
&& let Some(copy) = saved.as_deref().and_then(|d| worktree::saved_copy(d, &change.rel_path))
&& std::fs::read(&change.path.0).is_ok_and(|now| now == copy)
{
restamped.push((change.rel_path.clone(), worktree::stamp(&change.path.0)));
}
}
Ok(restamped)
@@ -1690,7 +1817,7 @@ impl AgentManager {
s.task.mcp_overrides = cleaned;
s.task.updated_ms = now_ms();
}
(changed, s.busy, !s.background_tasks.is_empty(), s.task.clone())
(changed, s.busy, !s.background_tasks.is_empty(), s.snapshot())
};
if changed {
task.persist();
@@ -1748,10 +1875,12 @@ impl Task {
session_id: file.session_id,
conversation,
wanted: file.wanted,
pending_model: file.pending_model,
model_choice: 0,
before: Arc::new(file.before),
saved: file.saved,
touched: file.touched.map(Arc::new),
turn: file.turn.map(Arc::new),
pending_rollback: file.pending_rollback,
title_renamed: file.title_renamed,
busy: false,
@@ -1785,31 +1914,48 @@ impl Task {
(s.before.clone(), s.touched.clone())
}
/// The changed files of the checkout as a turn starts, when the task records what its turns change.
async fn checkout_before_turn(&self) -> Option<Snapshot> {
let cwd = {
let s = self.state.lock();
s.touched.as_ref()?;
s.task.cwd.0.clone()
};
blocking(move || worktree::snapshot(&cwd)).await.ok()
/// Where the copies of the files already changed as the last turn started are kept.
fn turn_dir(&self) -> PathBuf {
self.shared.paths.store_dir.join(format!("{}.turn", self.id))
}
/// Records the files that changed in the checkout since `start`, as the turn ends, as the task's.
async fn record_turn_changes(&self, start: Option<Snapshot>) {
let Some(start) = start else { return };
let cwd = self.state.lock().task.cwd.0.clone();
let Ok(end) = blocking(move || worktree::snapshot(&cwd)).await else { return };
let changed = worktree::changed_between(&start, &end);
if changed.is_empty() {
return;
}
/// The checkout as the last turn started, with the folder of its copies.
fn last_turn(&self) -> (PathBuf, Option<Arc<worktree::TurnStart>>, PathBuf) {
let s = self.state.lock();
(s.task.cwd.0.clone(), s.turn.clone(), self.turn_dir())
}
/// Records the checkout as a turn starts: what the turn's changes are compared with.
async fn checkout_before_turn(&self) {
let (cwd, previous, dir) = self.last_turn();
let turn = match blocking(move || worktree::start_turn(&cwd, &dir, previous.as_deref())).await {
Ok(turn) => Some(Arc::new(turn)),
Err(e) => {
tracing::warn!("recording the checkout as a turn of agent task {} starts: {e}", self.id);
None
}
};
self.state.lock().turn = turn;
self.persist();
}
/// Records the files that changed in the checkout while the turn ran: the turn's, and in
/// the project's own checkout also the task's.
async fn record_turn_changes(&self) {
let (cwd, turn, _) = self.last_turn();
let Some(turn) = turn else { return };
let start = turn.clone();
let Ok((in_worktree, all)) = blocking(move || worktree::changed_in_turn(&cwd, &start)).await else { return };
{
let mut s = self.state.lock();
let Some(touched) = &s.touched else { return };
let mut touched = (**touched).clone();
touched.extend(changed);
s.touched = Some(Arc::new(touched));
if !in_worktree.is_empty()
&& let Some(touched) = &s.touched
{
let mut touched = (**touched).clone();
touched.extend(in_worktree);
s.touched = Some(Arc::new(touched));
}
s.turn = Some(Arc::new(worktree::TurnStart { changed: Some(all), ..(*turn).clone() }));
}
self.persist();
}
@@ -1826,7 +1972,7 @@ impl Task {
}
fn emit_task(&self) {
let task = self.state.lock().task.clone();
let task = self.state.lock().snapshot();
self.shared.emit(AgentEvent::Task { task: Box::new(task) });
}
@@ -1923,9 +2069,11 @@ impl Task {
session_id: s.session_id.clone(),
entries: s.conversation.main.entries.clone(),
wanted: s.wanted.clone(),
pending_model: s.pending_model.clone(),
before: (*s.before).clone(),
saved: s.saved.clone(),
touched: s.touched.as_deref().cloned(),
turn: s.turn.as_deref().cloned(),
subagents: s.conversation.saved_subagents(),
pending_rollback: s.pending_rollback,
title_renamed: s.title_renamed,
@@ -1977,11 +2125,11 @@ impl Task {
/// the user stops one. The caller set `busy`.
async fn run(self: Arc<Self>, mut prompt: AgentPrompt) {
loop {
let start = self.checkout_before_turn().await;
self.checkout_before_turn().await;
let result = self.turn(&prompt).await;
self.cancel_pending.store(false, Ordering::Release);
tokio::time::sleep(TURN_GRACE).await;
self.record_turn_changes(start).await;
self.record_turn_changes().await;
let changed = self.state.lock().conversation.end_turn(Some(now_ms()));
self.mark_dirty(changed);
let send_now = self.send_now.swap(false, Ordering::AcqRel);
@@ -2027,7 +2175,7 @@ impl Task {
}
}
/// Drops an idle resumable live session so the next turn reloads it with fresh MCP servers.
/// Drops an idle resumable live session so the next turn reloads it.
fn recycle_resumable_session(&self) {
self.mcp_reload_pending.store(false, Ordering::Release);
let live = {
@@ -2035,12 +2183,110 @@ impl Task {
if live.as_ref().is_some_and(|l| l.resumable && !l.peer.is_closed()) { live.take() } else { None }
};
if let Some(live) = live {
tracing::debug!("agent task {}: restarting idle resumable session for MCP override update", self.id);
tracing::debug!("agent task {}: recycling idle resumable session", self.id);
live.peer.kill();
self.clear_shown_background();
}
}
async fn switch_discovered_model(&self, target: AgentConfigOption, value: String) -> IdeResult<()> {
let provider = self.state.lock().task.provider.clone();
let spec = self.shared.spec(&provider).ok_or_else(|| IdeError::not_found("no such agent"))?;
let candidate = self.shared.paths.catalogs.fresh_model(&self.shared, &spec, &value).ok_or_else(|| {
IdeError::invalid(format!("{} has no value {value} in the current model catalog", target.name))
})?;
let model_choice = {
let mut s = self.state.lock();
s.model_choice += 1;
s.model_choice
};
// A prompt starting during the switch must not grab the peer we're about to recycle.
let _connecting = self.connecting.lock().await;
{
let s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
}
let live = self.live.lock().clone();
let result = if let Some(live) = live.as_ref().filter(|l| !l.peer.is_closed()) {
let (method, mut params) = config::set_request(&target, &value);
params["sessionId"] = json!(live.session);
match live.peer.request::<_, Value>(method, params, None).await {
Ok(reply) if config::accepts_model(&reply, &target.id, &value) => Ok(Some(reply)),
Ok(_) => Err(format!("The agent did not switch to model {value}.")),
Err(e) => Err(self.describe(e)),
}
} else {
Ok(None)
};
let accepted = {
let mut s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
let pending = match result {
Ok(Some(reply)) => {
if let Some(options) = reply.get("configOptions") {
config::merge_update(&mut s.task.config, options);
} else if s.task.model.as_deref() != Some(value.as_str()) {
s.task.config.retain(|o| !config::is_per_model_option(o));
}
let model =
if let Some(i) = s.task.config.iter().position(|o| o.category.as_deref() == Some("model")) {
&mut s.task.config[i]
} else {
s.task.config.push(target.clone());
s.task.config.last_mut().unwrap()
};
if !model.values.iter().any(|v| v.value == value) {
model.values.push(candidate);
}
model.current = Some(value.clone());
s.task.model = Some(value.clone());
sync_usage_context_size(&mut s.task);
false
}
refused => {
if s.session_id.is_none()
|| live.as_ref().is_some_and(|l| !l.resumable)
|| self.start_fresh.load(Ordering::Acquire)
{
return Err(IdeError::unavailable(
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
));
}
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
return Err(IdeError::invalid("wait until the agent is done"));
}
true
}
};
s.wanted.retain(|c| c.id != target.id);
s.pending_model = pending.then(|| target.id.clone());
s.wanted.push(AgentConfigChoice { id: target.id, value });
(!pending).then(|| {
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
(s.task.config.clone(), model)
})
};
if let Some((config, model)) = accepted {
self.shared.remember(&provider, Some(&config), None, model.as_deref());
} else {
self.recycle_resumable_session();
}
self.persist();
self.emit_task();
Ok(())
}
/// Stops the agent's process once the task has stayed idle for [`IDLE_RELEASE`], so
/// finished tasks don't keep an agent (and what it started) running. Only an agent that
/// reloads its session: the next message starts it again with the conversation intact.
@@ -2288,10 +2534,12 @@ impl Task {
{
return Ok(live);
}
let (provider_id, cwd, saved) = {
let (provider_id, cwd, saved, pending) = {
let s = self.state.lock();
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone())
let pending = s.pending_model().map(|choice| (choice.clone(), s.task.model.clone()));
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), pending)
};
let pending_model = pending.as_ref().map(|(choice, _)| choice);
let raw_spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
let can_fallback =
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
@@ -2300,8 +2548,8 @@ impl Task {
} else {
raw_spec.clone()
};
let live = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone()).await {
Ok(live) => live,
let opened = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone(), pending_model).await {
Ok(live) => Ok(live),
Err(err) if can_fallback && err.allow_acp_fallback => {
tracing::warn!(
"agent task {}: Copilot headless session setup failed ({}); falling back to `copilot --acp`",
@@ -2310,9 +2558,32 @@ impl Task {
);
self.shared.mark_copilot_acp_fallback(&raw_spec);
let acp_spec = native::copilot::acp_fallback_spec(&raw_spec);
self.open_session(&provider_id, acp_spec, &cwd, saved).await.map_err(|e| e.message)?
self.open_session(&provider_id, acp_spec, &cwd, saved, pending_model).await
}
Err(err) => Err(err),
};
let live = match opened {
Ok(live) => live,
Err(err) => {
if let Some((choice, previous)) = pending {
let mut s = self.state.lock();
if s.pending_model() == Some(&choice) {
s.pending_model = None;
s.wanted.retain(|c| c.id != choice.id);
if let Some(model) = s.task.config.iter_mut().find(|o| o.id == choice.id) {
model.current.clone_from(&previous);
}
s.task.model.clone_from(&previous);
if let Some(value) = previous {
s.wanted.push(AgentConfigChoice { id: choice.id, value });
}
drop(s);
self.persist();
self.emit_task();
}
}
return Err(err.message);
}
Err(err) => return Err(err.message),
};
*self.live.lock() = Some(live.clone());
Ok(live)
@@ -2324,6 +2595,7 @@ impl Task {
spec: provider::ProviderSpec,
cwd: &Path,
saved: Option<String>,
pending_model: Option<&AgentConfigChoice>,
) -> Result<Live, SessionOpenError> {
let launch_cwd = cwd.to_path_buf();
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
@@ -2373,6 +2645,12 @@ impl Task {
let mut tried_auth = false;
let mut session = None;
let start_fresh = self.start_fresh.load(Ordering::Acquire);
if pending_model.is_some() && (saved.is_none() || !can_load || start_fresh) {
return Err(SessionOpenError {
message: "The agent does not support resuming this session.".into(),
allow_acp_fallback: false,
});
}
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);
@@ -2388,6 +2666,16 @@ impl Task {
if let Some(message) = self.sign_in_error(&e, Some(&sign_in_message)) {
return Err(SessionOpenError { message, allow_acp_fallback: false });
}
if pending_model.is_some() {
return Err(SessionOpenError {
message: format!(
"Couldn't reopen this conversation's {} session: {}",
spec.name,
self.describe(e)
),
allow_acp_fallback: false,
});
}
self.start_fresh.store(true, Ordering::Release);
return Err(SessionOpenError {
message: format!(
@@ -2459,6 +2747,19 @@ impl Task {
});
let mut model_options = known;
for choice in &wanted {
let pending = pending_model == Some(choice);
if pending
&& !options.iter().any(|o| {
o.id == choice.id
&& (o.values.iter().any(|v| v.value == choice.value)
|| (known && o.current.as_deref() == Some(choice.value.as_str())))
})
{
return Err(SessionOpenError {
message: format!("The reloaded session does not offer model {}.", choice.value),
allow_acp_fallback: false,
});
}
// An option the session doesn't offer yet is set once it does (`apply_late_choices`).
let Some(o) = options.iter().find(|o| o.id == choice.id).cloned() else { continue };
if o.id == config::CURSOR_APPROVAL {
@@ -2479,6 +2780,12 @@ impl Task {
params["sessionId"] = json!(session_id);
match peer.request::<_, Value>(method, params, None).await {
Ok(reply) => {
if pending && !config::accepts_model(&reply, &o.id, &choice.value) {
return Err(SessionOpenError {
message: format!("The reloaded session did not switch to model {}.", choice.value),
allow_acp_fallback: false,
});
}
if let Some(fresh) = reply.get("configOptions") {
config::merge_update(&mut options, fresh);
model_options = true;
@@ -2492,6 +2799,9 @@ impl Task {
o.current = Some(choice.value.clone());
}
}
Err(e) if pending => {
return Err(SessionOpenError { message: self.describe(e), allow_acp_fallback: false });
}
Err(e) => tracing::warn!("agent task {}: setting {} to {} failed: {e}", self.id, o.id, choice.value),
}
}
@@ -2501,6 +2811,7 @@ impl Task {
let mut s = self.state.lock();
s.task.model = model_of(&options).or(s.task.model.take());
s.task.config = options;
s.pending_model = None;
s.task.capabilities = capabilities;
s.session_id = Some(session_id.clone());
self.start_fresh.store(false, Ordering::Release);
+436 -49
Переглянути файл
@@ -399,163 +399,429 @@ pub fn apply_save_json(
Ok(saved_names)
}
#[derive(Clone, Copy, PartialEq, Eq)]
const COPILOT_PLUGIN_MANIFESTS: &[&str] = &[
".github/plugin/plugin.json",
".plugin/plugin.json",
".claude-plugin/plugin.json",
".cursor-plugin/plugin.json",
"plugin.json",
];
#[derive(Clone, PartialEq, Eq)]
enum SourceFormat {
Jsonc,
CodexToml,
CopilotPlugin { root: PathBuf },
}
#[derive(Clone)]
struct SourceSpec {
id: &'static str,
label: &'static str,
id: String,
label: String,
path: PathBuf,
format: SourceFormat,
suggested_scope: McpScope,
native_provider: Option<&'static str>,
claude_project_lookup: bool,
disabled_servers: std::sync::Arc<BTreeSet<String>>,
}
#[derive(Default)]
struct CopilotSettings {
disabled_mcp_servers: std::sync::Arc<BTreeSet<String>>,
disabled_plugins: BTreeSet<String>,
}
fn external_source_specs(home_dir: Option<&Path>, workspace_root: Option<&Path>) -> Vec<SourceSpec> {
let mut specs = Vec::new();
let no_disabled: std::sync::Arc<BTreeSet<String>> = std::sync::Arc::new(BTreeSet::new());
if let Some(root) = workspace_root {
specs.push(SourceSpec {
id: "workspace-mcp",
label: "Project (.mcp.json)",
id: "workspace-mcp".into(),
label: "Project (.mcp.json)".into(),
path: root.join(".mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: Some("claude"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "vscode-mcp",
label: "VS Code (.vscode/mcp.json)",
id: "vscode-mcp".into(),
label: "VS Code (.vscode/mcp.json)".into(),
path: root.join(".vscode").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: None,
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "cursor-project",
label: "Cursor Project (.cursor/mcp.json)",
id: "cursor-project".into(),
label: "Cursor Project (.cursor/mcp.json)".into(),
path: root.join(".cursor").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: Some("cursor"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "codex-project",
label: "Codex Project (.codex/config.toml)",
id: "codex-project".into(),
label: "Codex Project (.codex/config.toml)".into(),
path: root.join(".codex").join("config.toml"),
format: SourceFormat::CodexToml,
suggested_scope: McpScope::Workspace,
native_provider: Some("codex"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "gemini-project",
label: "Gemini Project (.gemini/settings.json)",
id: "gemini-project".into(),
label: "Gemini Project (.gemini/settings.json)".into(),
path: root.join(".gemini").join("settings.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::Workspace,
native_provider: Some("gemini"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
}
if let Some(home) = home_dir {
let copilot_dir = home.join(".copilot");
let copilot_settings = read_copilot_settings(&copilot_dir);
specs.push(SourceSpec {
id: "copilot-cli",
label: "GitHub Copilot CLI",
path: home.join(".copilot").join("mcp-config.json"),
id: "copilot-cli".into(),
label: "GitHub Copilot CLI".into(),
path: copilot_dir.join("mcp-config.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("copilot"),
claude_project_lookup: false,
disabled_servers: copilot_settings.disabled_mcp_servers.clone(),
});
specs.extend(copilot_plugin_source_specs(&copilot_dir, &copilot_settings));
specs.push(SourceSpec {
id: "claude-code",
label: "Claude Code",
id: "claude-code".into(),
label: "Claude Code".into(),
path: home.join(".claude.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("claude"),
claude_project_lookup: true,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "codex",
label: "Codex",
id: "codex".into(),
label: "Codex".into(),
path: home.join(".codex").join("config.toml"),
format: SourceFormat::CodexToml,
suggested_scope: McpScope::User,
native_provider: Some("codex"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "cursor",
label: "Cursor",
id: "cursor".into(),
label: "Cursor".into(),
path: home.join(".cursor").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("cursor"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "gemini",
label: "Gemini CLI",
id: "gemini".into(),
label: "Gemini CLI".into(),
path: home.join(".gemini").join("settings.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: Some("gemini"),
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "jetbrains-air",
label: "JetBrains Air",
id: "jetbrains-air".into(),
label: "JetBrains Air".into(),
path: home.join(".jetbrains").join("mcp").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: None,
claude_project_lookup: false,
disabled_servers: no_disabled.clone(),
});
specs.push(SourceSpec {
id: "copilot-intellij",
label: "GitHub Copilot (JetBrains)",
id: "copilot-intellij".into(),
label: "GitHub Copilot (JetBrains)".into(),
path: home.join(".config").join("github-copilot").join("intellij").join("mcp.json"),
format: SourceFormat::Jsonc,
suggested_scope: McpScope::User,
native_provider: None,
claude_project_lookup: false,
disabled_servers: no_disabled,
});
}
specs
}
fn read_source_servers(spec: &SourceSpec, workspace_root: Option<&Path>) -> BTreeMap<String, AgentMcpServer> {
let Ok(text) = std::fs::read_to_string(&spec.path) else {
return BTreeMap::new();
fn read_copilot_settings(copilot_dir: &Path) -> CopilotSettings {
let Ok(text) = std::fs::read_to_string(copilot_dir.join("settings.json")) else {
return CopilotSettings::default();
};
if spec.format == SourceFormat::CodexToml {
return parse_codex_toml_servers(&text);
}
let Ok(root) = parse_jsonc_value(&text) else {
return BTreeMap::new();
return CopilotSettings::default();
};
let mut servers = extract_servers_from_root(&root, None);
if spec.claude_project_lookup
&& let Some(ws) = workspace_root
&& let Some(projects) = root.get("projects").and_then(Value::as_object)
{
let ws_canon = dunce::canonicalize(ws).unwrap_or_else(|_| ws.to_path_buf());
for (proj_key, proj_val) in projects {
let matches = Path::new(proj_key) == ws || dunce::canonicalize(proj_key).is_ok_and(|c| c == ws_canon);
if matches {
for (name, srv) in extract_servers_from_root(proj_val, None) {
servers.insert(name, srv);
let disabled_mcp_servers = root
.get("disabledMcpServers")
.and_then(Value::as_array)
.map(|arr| {
arr.iter()
.filter_map(|v| v.as_str().map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned))
.collect::<BTreeSet<_>>()
})
.unwrap_or_default();
let disabled_plugins = root
.get("enabledPlugins")
.and_then(Value::as_object)
.map(|obj| {
obj.iter()
.filter(|(_, v)| v.as_bool() == Some(false))
.map(|(k, _)| k.trim().to_owned())
.filter(|k| !k.is_empty())
.collect::<BTreeSet<_>>()
})
.unwrap_or_default();
CopilotSettings { disabled_mcp_servers: std::sync::Arc::new(disabled_mcp_servers), disabled_plugins }
}
fn copilot_plugin_source_specs(copilot_dir: &Path, settings: &CopilotSettings) -> Vec<SourceSpec> {
let Ok(text) = std::fs::read_to_string(copilot_dir.join("config.json")) else {
return Vec::new();
};
let Ok(root) = parse_jsonc_value(&text) else {
return Vec::new();
};
let Some(installed) = root.get("installedPlugins").and_then(Value::as_array) else {
return Vec::new();
};
let mut seen_ids = HashSet::new();
let mut specs = Vec::new();
for entry in installed {
let Some(obj) = entry.as_object() else { continue };
if obj.get("enabled").and_then(Value::as_bool) == Some(false) {
continue;
}
let Some(name) = obj.get("name").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty()) else {
continue;
};
let marketplace = obj.get("marketplace").and_then(Value::as_str).map(str::trim).unwrap_or_default();
if settings.disabled_plugins.contains(name)
|| (!marketplace.is_empty()
&& (settings.disabled_plugins.contains(&format!("{name}@{marketplace}"))
|| settings.disabled_plugins.contains(&format!("{marketplace}/{name}"))))
{
continue;
}
let Some(raw_cache) = obj.get("cache_path").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty())
else {
continue;
};
let plugin_root =
if Path::new(raw_cache).is_relative() { copilot_dir.join(raw_cache) } else { PathBuf::from(raw_cache) };
if !plugin_root.is_dir() {
continue;
}
let Some((manifest_path, _)) = read_copilot_plugin_servers(&plugin_root) else {
continue;
};
let base_id = if marketplace.is_empty() {
format!("copilot-plugin:{name}")
} else {
format!("copilot-plugin:{marketplace}/{name}")
};
let mut id = base_id.clone();
let mut suffix = 2usize;
while !seen_ids.insert(id.clone()) {
id = format!("{base_id}#{suffix}");
suffix += 1;
}
let label = if marketplace.is_empty() {
format!("GitHub Copilot Plugin ({name})")
} else {
format!("GitHub Copilot Plugin ({name} · {marketplace})")
};
specs.push(SourceSpec {
id,
label,
path: manifest_path,
format: SourceFormat::CopilotPlugin { root: plugin_root },
suggested_scope: McpScope::User,
native_provider: Some("copilot"),
claude_project_lookup: false,
disabled_servers: settings.disabled_mcp_servers.clone(),
});
}
specs
}
fn resolve_within_dir(base_dir: &Path, candidate: &Path) -> Option<PathBuf> {
if candidate.as_os_str().is_empty() {
return None;
}
let base_canon = dunce::canonicalize(base_dir).ok()?;
let clean = candidate.strip_prefix(".").unwrap_or(candidate);
let joined = if clean.is_relative() { base_dir.join(clean) } else { clean.to_path_buf() };
let meta = std::fs::metadata(&joined).ok()?;
if !meta.is_file() {
return None;
}
let target_canon = dunce::canonicalize(&joined).ok()?;
target_canon.starts_with(&base_canon).then_some(joined)
}
fn expand_plugin_root_vars(value: &str, root: &str) -> String {
value.replace("${COPILOT_PLUGIN_ROOT}", root).replace("${CLAUDE_PLUGIN_ROOT}", root).replace("${PLUGIN_ROOT}", root)
}
fn expand_plugin_servers(servers: &mut BTreeMap<String, AgentMcpServer>, plugin_root: &Path) {
let root = plugin_root.to_string_lossy();
for srv in servers.values_mut() {
if let Some(cmd) = srv.command.as_mut() {
*cmd = expand_plugin_root_vars(cmd, &root);
}
for arg in &mut srv.args {
*arg = expand_plugin_root_vars(arg, &root);
}
if let Some(url) = srv.url.as_mut() {
*url = expand_plugin_root_vars(url, &root);
}
for val in srv.env.values_mut() {
*val = expand_plugin_root_vars(val, &root);
}
for val in srv.headers.values_mut() {
*val = expand_plugin_root_vars(val, &root);
}
}
}
fn extract_plugin_manifest_servers(
plugin_root: &Path,
manifest_path: &Path,
mcp_val: &Value,
) -> (PathBuf, BTreeMap<String, AgentMcpServer>) {
match mcp_val {
Value::String(rel) => {
if let Some(path) = resolve_within_dir(plugin_root, Path::new(rel.trim())) {
let map = read_external_file(&path);
return (path, map);
}
(manifest_path.to_path_buf(), BTreeMap::new())
}
Value::Object(_) => {
let wrapper = json!({ "mcpServers": mcp_val });
(manifest_path.to_path_buf(), extract_servers_from_root(&wrapper, None))
}
Value::Array(items) => {
let mut merged = BTreeMap::new();
let mut first_path: Option<PathBuf> = None;
for item in items {
match item {
Value::String(rel) => {
if let Some(path) = resolve_within_dir(plugin_root, Path::new(rel.trim())) {
let map = read_external_file(&path);
if !map.is_empty() && first_path.is_none() {
first_path = Some(path);
}
merged.extend(map);
}
}
Value::Object(_) => {
let map = extract_servers_from_root(item, None);
if !map.is_empty() && first_path.is_none() {
first_path = Some(manifest_path.to_path_buf());
}
merged.extend(map);
}
_ => {}
}
}
(first_path.unwrap_or_else(|| manifest_path.to_path_buf()), merged)
}
_ => (manifest_path.to_path_buf(), BTreeMap::new()),
}
}
fn read_copilot_plugin_servers(plugin_root: &Path) -> Option<(PathBuf, BTreeMap<String, AgentMcpServer>)> {
if let Some(dot_mcp) = resolve_within_dir(plugin_root, Path::new(".mcp.json")) {
let mut servers = read_external_file(&dot_mcp);
if !servers.is_empty() {
expand_plugin_servers(&mut servers, plugin_root);
return Some((dot_mcp, servers));
}
}
for rel in COPILOT_PLUGIN_MANIFESTS {
let Some(manifest_path) = resolve_within_dir(plugin_root, Path::new(rel)) else {
continue;
};
let Ok(text) = std::fs::read_to_string(&manifest_path) else {
continue;
};
let Ok(manifest) = parse_jsonc_value(&text) else {
continue;
};
let Some(mcp_val) = manifest.get("mcpServers") else {
continue;
};
let (source_path, mut servers) = extract_plugin_manifest_servers(plugin_root, &manifest_path, mcp_val);
if !servers.is_empty() {
expand_plugin_servers(&mut servers, plugin_root);
return Some((source_path, servers));
}
}
None
}
fn read_source_servers(spec: &SourceSpec, workspace_root: Option<&Path>) -> BTreeMap<String, AgentMcpServer> {
let mut servers = match &spec.format {
SourceFormat::CopilotPlugin { root } => {
read_copilot_plugin_servers(root).map(|(_, map)| map).unwrap_or_default()
}
SourceFormat::CodexToml => {
let Ok(text) = std::fs::read_to_string(&spec.path) else {
return BTreeMap::new();
};
parse_codex_toml_servers(&text)
}
SourceFormat::Jsonc => {
let Ok(text) = std::fs::read_to_string(&spec.path) else {
return BTreeMap::new();
};
let Ok(root) = parse_jsonc_value(&text) else {
return BTreeMap::new();
};
let mut map = extract_servers_from_root(&root, None);
if spec.claude_project_lookup
&& let Some(ws) = workspace_root
&& let Some(projects) = root.get("projects").and_then(Value::as_object)
{
let ws_canon = dunce::canonicalize(ws).unwrap_or_else(|_| ws.to_path_buf());
for (proj_key, proj_val) in projects {
let matches =
Path::new(proj_key) == ws || dunce::canonicalize(proj_key).is_ok_and(|c| c == ws_canon);
if matches {
for (name, srv) in extract_servers_from_root(proj_val, None) {
map.insert(name, srv);
}
}
}
}
map
}
};
for name in spec.disabled_servers.iter() {
if let Some(srv) = servers.get_mut(name) {
srv.enabled = false;
}
}
servers
@@ -612,8 +878,8 @@ pub fn discover_external_sources(home_dir: Option<&Path>, workspace_root: Option
})
.collect();
out.push(McpExternalSource {
id: spec.id.to_owned(),
label: spec.label.to_owned(),
id: spec.id,
label: spec.label,
path: IpcPath(spec.path),
suggested_scope: spec.suggested_scope,
native_provider: spec.native_provider.map(str::to_owned),
@@ -641,7 +907,7 @@ pub fn apply_import_selected(
let mut by_source: BTreeMap<&str, BTreeMap<String, AgentMcpServer>> = BTreeMap::new();
for spec in &specs {
if selections.iter().any(|s| s.source_id == spec.id) {
by_source.insert(spec.id, read_source_servers(spec, workspace_root));
by_source.insert(spec.id.as_str(), read_source_servers(spec, workspace_root));
}
}
let target = match scope {
@@ -1370,4 +1636,125 @@ mod tests {
assert_eq!(workspace["events-sse"].transport, McpTransport::Sse);
assert_eq!(workspace["events-sse"].url.as_deref(), Some("https://sse.example.com/events"));
}
#[test]
fn discovers_and_imports_copilot_installed_plugin_mcp_servers() {
let tmp = tempfile::tempdir().unwrap();
let home = tmp.path().join("home");
let copilot = home.join(".copilot");
let azure_root = copilot.join("installed-plugins/_direct/azure-skills");
let inline_root = copilot.join("installed-plugins/awesome-copilot/inline-tools");
let disabled_root = copilot.join("installed-plugins/_direct/disabled-plug");
let outside_root = tmp.path().join("outside");
std::fs::create_dir_all(azure_root.join(".plugin")).unwrap();
std::fs::create_dir_all(inline_root.join(".claude-plugin")).unwrap();
std::fs::create_dir_all(&disabled_root).unwrap();
std::fs::create_dir_all(&outside_root).unwrap();
std::fs::write(
azure_root.join(".plugin/plugin.json"),
r#"{"name":"azure","version":"1.2.106","mcpServers":"./.mcp.json"}"#,
)
.unwrap();
std::fs::write(
azure_root.join(".mcp.json"),
r#"{"mcpServers":{"azure":{"command":"npx","args":["-y","@azure/mcp@latest","${COPILOT_PLUGIN_ROOT}/cfg"],"env":{"PLUG_DIR":"${CLAUDE_PLUGIN_ROOT}"}}}}"#,
)
.unwrap();
std::fs::write(
inline_root.join(".claude-plugin/plugin.json"),
r#"{"name":"inline-tools","version":"0.1.0","mcpServers":{"inline-srv":{"command":"${PLUGIN_ROOT}/bin/run","args":["--stdio"]},"muted-srv":{"command":"echo","args":["off"]}}}"#,
)
.unwrap();
std::fs::write(
disabled_root.join(".mcp.json"),
r#"{"mcpServers":{"never":{"command":"npx","args":["never"]}}}"#,
)
.unwrap();
std::fs::write(outside_root.join("secret.json"), r#"{"mcpServers":{"escaped":{"command":"sh"}}}"#).unwrap();
let escape_root = copilot.join("installed-plugins/_direct/escape-plug");
std::fs::create_dir_all(escape_root.join(".plugin")).unwrap();
std::fs::write(
escape_root.join(".plugin/plugin.json"),
r#"{"name":"escape-plug","mcpServers":"../../../../outside/secret.json"}"#,
)
.unwrap();
// `~/.copilot/config.json` includes leading `//` comments in Copilot CLI.
let config_json = format!(
"// Managed automatically.\n{}",
serde_json::json!({
"installedPlugins": [
{
"name": "azure",
"marketplace": "",
"enabled": true,
"cache_path": azure_root,
},
{
"name": "inline-tools",
"marketplace": "awesome-copilot",
"enabled": true,
"cache_path": inline_root,
},
{
"name": "disabled-plug",
"marketplace": "",
"enabled": false,
"cache_path": disabled_root,
},
{
"name": "escape-plug",
"marketplace": "",
"enabled": true,
"cache_path": escape_root,
}
]
})
);
std::fs::write(copilot.join("config.json"), config_json).unwrap();
std::fs::write(copilot.join("settings.json"), r#"{"disabledMcpServers":["muted-srv"]}"#).unwrap();
let sources = discover_external_sources(Some(&home), None);
assert_eq!(sources.len(), 2);
let azure_src = sources.iter().find(|s| s.id == "copilot-plugin:azure").unwrap();
assert_eq!(azure_src.label, "GitHub Copilot Plugin (azure)");
assert_eq!(azure_src.native_provider.as_deref(), Some("copilot"));
assert_eq!(azure_src.path.0, azure_root.join(".mcp.json"));
assert_eq!(azure_src.servers.len(), 1);
assert!(azure_src.servers[0].enabled);
assert_eq!(
azure_src.servers[0].args,
vec!["-y", "@azure/mcp@latest", &format!("{}/cfg", azure_root.display())]
);
let inline_src = sources.iter().find(|s| s.id == "copilot-plugin:awesome-copilot/inline-tools").unwrap();
assert_eq!(inline_src.label, "GitHub Copilot Plugin (inline-tools · awesome-copilot)");
assert_eq!(inline_src.path.0, inline_root.join(".claude-plugin/plugin.json"));
let active = inline_src.servers.iter().find(|s| s.name == "inline-srv").unwrap();
assert!(active.enabled);
assert_eq!(active.command.as_deref(), Some(format!("{}/bin/run", inline_root.display()).as_str()));
let muted = inline_src.servers.iter().find(|s| s.name == "muted-srv").unwrap();
assert!(!muted.enabled);
let mut user = BTreeMap::new();
let mut workspace = BTreeMap::new();
let imported = apply_import_selected(
&mut user,
&mut workspace,
Some(&home),
None,
McpScope::User,
&[McpImportSelection { source_id: "copilot-plugin:azure".into(), name: "azure".into() }],
false,
)
.unwrap();
assert_eq!(imported, vec!["azure".to_string()]);
assert_eq!(user["azure"].env.get("PLUG_DIR").map(String::as_str), Some(azure_root.to_str().unwrap()));
}
}
+2
Переглянути файл
@@ -672,6 +672,8 @@ pub enum AgentChangesView {
SinceStart,
/// The uncommitted files against `HEAD`; commits made since the start stay.
Group,
/// What the last turn changed, against the checkout as that turn started.
LastTurn,
}
/// A task's uncommitted files and the commits made since it started.
+182 -3
Переглянути файл
@@ -2852,7 +2852,10 @@ async fn task_project_root_controls_local_and_worktree_repositories() {
let changes = mgr.changes(&task.id).await.unwrap();
assert_eq!(changes.len(), 1);
assert_eq!(changes[0].path.0, task.cwd.0.join("file.txt"));
assert_eq!(mgr.base_text(&task.id, changes[0].path.0.clone()).await.unwrap().as_deref(), Some("original\n"));
assert_eq!(
mgr.base_text(&task.id, changes[0].path.0.clone(), AgentChangesView::SinceStart).await.unwrap().as_deref(),
Some("original\n")
);
let saved = std::fs::read(root.join("store").join(format!("{}.json", task.id))).unwrap();
assert!(String::from_utf8(saved).unwrap().contains("projectRoot"));
let mut old = serde_json::to_value(&task).unwrap();
@@ -3636,6 +3639,178 @@ async fn changed(mgr: &AgentManager, id: &str) -> Vec<String> {
mgr.changes(id).await.unwrap().into_iter().map(|c| c.rel_path).collect()
}
/// Waits until the turn asks for permission, runs `work` (what the agent does), then stops it.
async fn one_turn(mgr: &AgentManager, id: &str, prompt: Option<&str>, work: impl FnOnce()) {
if let Some(prompt) = prompt {
mgr.prompt(id, text(prompt), false).await.unwrap();
}
wait_for(mgr, id, AgentStatus::NeedsInput).await;
work();
mgr.cancel(id, None).unwrap();
wait_for(mgr, id, AgentStatus::Ready).await;
}
async fn turn_changed(mgr: &AgentManager, id: &str) -> Vec<(String, ide_vcs::ChangeKind, u32, u32)> {
let changes = mgr.turn_changes(id).await.unwrap();
changes.into_iter().map(|c| (c.rel_path, c.kind, c.added, c.removed)).collect()
}
#[tokio::test(flavor = "multi_thread")]
async fn the_last_turn_lists_and_rolls_back_only_its_own_changes() {
use ide_vcs::ChangeKind::{Added, Deleted, Modified};
for isolation in [Isolation::Local, Isolation::Worktree] {
for eol in EOLS {
let repo = Checkout::new(eol);
repo.write("a.txt", "base\n");
repo.write("gone.txt", "base\n");
repo.write("mine.txt", "base\n");
repo.commit("init");
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask {
prompt: text("Hello"),
provider: "claude".into(),
isolation,
..Default::default()
})
.await
.unwrap();
let cwd = task.cwd.0.clone();
let write = |rel: &str, text: &str| {
let text = match eol {
Eol::Lf => text.to_owned(),
Eol::Crlf => text.replace('\n', "\r\n"),
};
std::fs::write(cwd.join(rel), text).unwrap();
};
let read = |rel: &str| std::fs::read_to_string(cwd.join(rel)).unwrap().replace("\r\n", "\n");
let case = format!("{isolation:?} {eol:?}");
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty(), "{case}: no turn has ended yet");
one_turn(&mgr, &task.id, None, || {
write("a.txt", "base\nturn 1\n");
write("one.txt", "one\n");
})
.await;
// The user's own work between the turns belongs to neither.
write("mine.txt", "base\nmine\n");
one_turn(&mgr, &task.id, Some("more"), || {
write("a.txt", "base\nturn 1\nturn 2\n");
write("one.txt", "one\ntwo\n");
write("two.txt", "two\n");
std::fs::remove_file(cwd.join("gone.txt")).unwrap();
})
.await;
// And after the turn.
write("later.txt", "mine\n");
assert_eq!(
turn_changed(&mgr, &task.id).await,
[
("a.txt".into(), Modified, 1, 0),
("gone.txt".into(), Deleted, 0, 1),
("one.txt".into(), Modified, 1, 0),
("two.txt".into(), Added, 1, 0),
],
"{case}"
);
let turn_base = |rel: &str| {
let path = cwd.join(rel);
let mgr = &mgr;
let id = task.id.clone();
async move {
let text = mgr.base_text(&id, path, AgentChangesView::LastTurn).await.unwrap();
text.map(|t| t.replace("\r\n", "\n"))
}
};
assert_eq!(turn_base("a.txt").await.as_deref(), Some("base\nturn 1\n"), "{case}");
assert_eq!(turn_base("gone.txt").await.as_deref(), Some("base\n"), "{case}");
assert_eq!(turn_base("two.txt").await, None, "{case}");
let whole: Vec<String> = changed(&mgr, &task.id).await;
assert!(["a.txt", "one.txt"].iter().all(|f| whole.iter().any(|w| w == f)), "{case}: {whole:?}");
// One file, then the rest, after a restart: from the copies saved as the turn started.
mgr.rollback_changes(&task.id, Some(vec!["one.txt".into()]), AgentChangesView::LastTurn).await.unwrap();
assert_eq!(read("one.txt"), "one\n", "{case}");
assert_eq!(turn_changed(&mgr, &task.id).await.len(), 3, "{case}");
mgr.shutdown();
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
mgr.rollback_changes(&task.id, None, AgentChangesView::LastTurn).await.unwrap();
assert_eq!(read("a.txt"), "base\nturn 1\n", "{case}");
assert_eq!(read("gone.txt"), "base\n", "{case}");
assert!(!cwd.join("two.txt").exists(), "{case}");
assert_eq!(read("mine.txt"), "base\nmine\n", "{case}: the user's edit between turns stays");
assert_eq!(read("later.txt"), "mine\n", "{case}: and the one after");
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty(), "{case}");
// The task's own changes from its first turn stay.
let whole: Vec<String> = changed(&mgr, &task.id).await;
assert!(["a.txt", "one.txt"].iter().all(|f| whole.iter().any(|w| w == f)), "{case}: {whole:?}");
mgr.delete(&task.id, true).await.unwrap();
assert!(!repo.dir.join("store").join(format!("{}.turn", task.id)).exists(), "{case}");
}
}
}
#[tokio::test(flavor = "multi_thread")]
async fn rolling_back_the_whole_task_leaves_the_last_turn_nothing_to_list() {
let repo = Checkout::new(Eol::Lf);
repo.write("a.txt", "base\n");
repo.commit("init");
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask { prompt: text("Hello"), provider: "claude".into(), ..Default::default() })
.await
.unwrap();
one_turn(&mgr, &task.id, None, || repo.write("a.txt", "base\nturn 1\n")).await;
one_turn(&mgr, &task.id, Some("more"), || repo.write("a.txt", "base\nturn 1\nturn 2\n")).await;
assert_eq!(turn_changed(&mgr, &task.id).await.len(), 1);
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
assert_eq!(repo.read("a.txt"), "base\n");
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty());
}
#[tokio::test(flavor = "multi_thread")]
async fn a_commit_made_in_the_last_turn_is_among_its_changes() {
let repo = Checkout::new(Eol::Lf);
repo.write("a.txt", "base\n");
repo.commit("init");
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask {
prompt: text("Hello"),
provider: "claude".into(),
isolation: Isolation::Worktree,
..Default::default()
})
.await
.unwrap();
let cwd = task.cwd.0.clone();
let git = |args: &[&str]| {
let ok = std::process::Command::new("git")
.args(["-c", "user.name=t", "-c", "user.email=t@t", "-c", "commit.gpgsign=false"])
.args(args)
.current_dir(&cwd)
.status()
.unwrap()
.success();
assert!(ok, "{args:?}");
};
one_turn(&mgr, &task.id, None, || {
std::fs::write(cwd.join("a.txt"), "base\nagent\n").unwrap();
std::fs::write(cwd.join("new.txt"), "new\n").unwrap();
git(&["add", "."]);
git(&["commit", "-q", "-m", "agent"]);
})
.await;
let rel: Vec<String> = mgr.turn_changes(&task.id).await.unwrap().into_iter().map(|c| c.rel_path).collect();
assert_eq!(rel, ["a.txt", "new.txt"]);
mgr.rollback_changes(&task.id, None, AgentChangesView::LastTurn).await.unwrap();
assert_eq!(std::fs::read_to_string(cwd.join("a.txt")).unwrap(), "base\n");
assert!(!cwd.join("new.txt").exists());
mgr.delete(&task.id, true).await.unwrap();
}
#[tokio::test(flavor = "multi_thread")]
async fn work_uncommitted_by_a_reset_during_a_local_task_is_not_rolled_back() {
for eol in EOLS {
@@ -3652,7 +3827,7 @@ async fn work_uncommitted_by_a_reset_during_a_local_task_is_not_rolled_back() {
repo.git(&["reset", "-q", "--soft", "HEAD~1"]);
assert_eq!(changed(&mgr, &task.id).await, ["a.txt"], "{eol:?}");
let base = mgr.base_text(&task.id, repo.dir.join("a.txt")).await.unwrap();
let base = mgr.base_text(&task.id, repo.dir.join("a.txt"), AgentChangesView::SinceStart).await.unwrap();
assert_eq!(base.map(|b| b.replace("\r\n", "\n")).as_deref(), Some("base\n"), "{eol:?}");
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
assert_eq!(repo.read("a.txt"), "base\n", "{eol:?}");
@@ -3792,7 +3967,11 @@ async fn a_local_task_in_a_repository_without_commits_lists_and_rolls_back_its_c
let (mgr, task) = repo.task().await;
repo.write("new.txt", "agent\n");
assert_eq!(changed(&mgr, &task.id).await, ["new.txt"], "{eol:?}");
assert_eq!(mgr.base_text(&task.id, repo.dir.join("new.txt")).await.unwrap(), None, "{eol:?}");
assert_eq!(
mgr.base_text(&task.id, repo.dir.join("new.txt"), AgentChangesView::SinceStart).await.unwrap(),
None,
"{eol:?}"
);
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
assert!(!repo.dir.join("new.txt").exists(), "{eol:?}");
+249 -2
Переглянути файл
@@ -3,6 +3,7 @@
use crate::model::{AgentChange, AgentChanges, AgentCommit};
use ide_core::{IdeError, IdeResult, IpcPath};
use ide_vcs::{ChangeKind, LogQuery, Repo};
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};
use std::time::{Duration, UNIX_EPOCH};
@@ -610,7 +611,6 @@ pub(crate) fn restore(
before: &BTreeMap<String, Stamp>,
saved: Option<&Path>,
) -> IdeResult<()> {
let path = &change.path.0;
let content = match before.get(&change.rel_path) {
Some(None) => None,
Some(Some(_)) => {
@@ -626,11 +626,16 @@ pub(crate) fn restore(
None => match rev {
Some(rev) => {
let repo = Repo::discover(cwd)?.ok_or_else(|| IdeError::invalid("not in a git repository"))?;
repo.file_bytes_at(path, Some(rev))?
repo.file_bytes_at(&change.path.0, Some(rev))?
}
None => None,
},
};
put(&change.path.0, content)
}
/// Writes `content` to `path`, or removes the file when there is none.
fn put(path: &Path, content: Option<Vec<u8>>) -> IdeResult<()> {
match content {
Some(bytes) => {
if let Some(parent) = path.parent() {
@@ -646,6 +651,187 @@ pub(crate) fn restore(
Ok(())
}
/// The bytes of the copy of `rel` saved in `dir`, if there is one.
pub(crate) fn saved_copy(dir: &Path, rel: &str) -> Option<Vec<u8>> {
std::fs::read(dir.join(saved_name(rel))).ok()
}
/// The checkout as the task's last turn started: what that turn's changes are compared with
/// and rolled back to. Recorded like the task's own start: `HEAD`, the files already changed,
/// and copies of those.
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct TurnStart {
/// `HEAD` then (`None` outside a repository or before its first commit).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub head: Option<String>,
/// The files already changed then, stamped.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub before: BTreeMap<String, Stamp>,
/// The files among `before` with a copy in the task's turn folder.
#[serde(default, skip_serializing_if = "BTreeSet::is_empty")]
pub saved: BTreeSet<String>,
/// The files that changed while the turn ran, recorded as it ended (`None` while it runs).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub changed: Option<BTreeSet<String>>,
}
/// Records the checkout at `cwd` as a turn starts, with copies of its changed files in `dir`.
/// The copies `previous` saved of files unchanged since are kept rather than made again, so
/// starting a turn copies little more than what the turn before it changed.
pub(crate) fn start_turn(cwd: &Path, dir: &Path, previous: Option<&TurnStart>) -> IdeResult<TurnStart> {
let Some(repo) = discover(cwd)? else { return Ok(TurnStart::default()) };
let head = repo.head()?.1;
// As the turn's end is read, so the two compare.
let before = snapshot(cwd)?;
let mut saved = BTreeSet::new();
match previous {
Some(previous) => {
for rel in &previous.saved {
let unchanged =
before.get(rel).is_some_and(|now| now.is_some() && previous.before.get(rel) == Some(now));
if unchanged {
saved.insert(rel.clone());
} else {
let _ = std::fs::remove_file(dir.join(saved_name(rel)));
}
}
}
None => {
let _ = std::fs::remove_dir_all(dir);
}
}
for (rel, stamp) in &before {
let path = repo.root().join(rel);
if stamp.is_none()
|| saved.contains(rel)
|| !std::fs::metadata(&path).is_ok_and(|m| m.is_file() && m.len() <= SAVED_MAX)
{
continue;
}
std::fs::create_dir_all(dir)?;
// One that can't be copied is listed but can't be rolled back, as a large one.
if std::fs::copy(&path, dir.join(saved_name(rel))).is_ok() {
saved.insert(rel.clone());
}
}
Ok(TurnStart { head, before, saved, changed: None })
}
/// The files that changed in `cwd` since the turn `start` began: in the working tree (as
/// `changed_between` sees them), and in the commits made since.
pub(crate) fn changed_in_turn(cwd: &Path, start: &TurnStart) -> IdeResult<(Vec<String>, BTreeSet<String>)> {
let end = snapshot(cwd)?;
let worktree = changed_between(&start.before, &end);
let mut all: BTreeSet<String> = worktree.iter().cloned().collect();
if let Some(repo) = discover(cwd)?
&& let (Some(from), Some(to)) = (&start.head, repo.head()?.1)
&& *from != to
{
for f in repo.diff_revisions(from, &to)? {
all.extend(f.old_path);
all.insert(f.path);
}
}
Ok((worktree, all))
}
/// The content of `rel` as the turn `start` began (`None`: no file), its copies in `dir`.
fn at_turn_start(repo: &Repo, rel: &str, start: &TurnStart, dir: &Path) -> IdeResult<Option<Vec<u8>>> {
match start.before.get(rel) {
Some(None) => Ok(None),
Some(Some(_)) => match start.saved.contains(rel).then(|| saved_copy(dir, rel)).flatten() {
Some(bytes) => Ok(Some(bytes)),
None => Err(IdeError::invalid(format!(
"{rel} had changes when the turn started that weren't saved; roll it back in Git instead"
))),
},
None => match &start.head {
Some(head) => repo.file_bytes_at(&repo.root().join(rel), Some(head)),
None => Ok(None),
},
}
}
/// Added and removed lines from `old` to `new`; none for binary content.
fn line_stats(old: Option<&[u8]>, new: Option<&[u8]>) -> (u32, u32) {
if [old, new].iter().flatten().any(|b| b.contains(&0)) {
return (0, 0);
}
let text = |b: Option<&[u8]>| b.map(|b| String::from_utf8_lossy(b).into_owned()).unwrap_or_default();
ide_vcs::diff_hunks(&text(old), &text(new))
.iter()
.fold((0, 0), |(added, removed), h| (added + h.lines, removed + h.old_lines))
}
/// The files among `changed` that differ from how they were as the turn `start` began.
pub(crate) fn turn_changes(
cwd: &Path,
start: &TurnStart,
dir: &Path,
changed: &BTreeSet<String>,
) -> IdeResult<Vec<AgentChange>> {
let Some(repo) = discover(cwd)? else { return Ok(Vec::new()) };
let mut out = Vec::new();
for rel in changed {
let path = repo.root().join(rel);
// A folder (a submodule, say) or a file that can't be read has nothing to compare.
let Some(now) = existing(&path) else { continue };
let (kind, (added, removed)) = match at_turn_start(&repo, rel, start, dir) {
Ok(then) if then == now => continue,
Ok(then) => {
let kind = match (&then, &now) {
(None, _) => ChangeKind::Added,
(_, None) => ChangeKind::Deleted,
_ => ChangeKind::Modified,
};
(kind, line_stats(then.as_deref(), now.as_deref()))
}
// Its start wasn't saved: listed, without counts.
Err(_) => (ChangeKind::Modified, (0, 0)),
};
out.push(AgentChange { path: IpcPath(path), rel_path: rel.clone(), kind, added, removed, old_path: None });
}
Ok(out)
}
/// The text of `path` as the turn `start` began, `None` when there was no file.
pub(crate) fn turn_text(cwd: &Path, path: &Path, start: &TurnStart, dir: &Path) -> IdeResult<Option<String>> {
let Some(repo) = discover(cwd)? else { return Ok(None) };
let rel = rel_in(repo.root(), path)?;
if let (None, Some(head)) = (start.before.get(&rel), &start.head) {
return file_at(cwd, path, head);
}
let Some(bytes) = at_turn_start(&repo, &rel, start, dir)? else { return Ok(None) };
let encoding = match ide_vfs::load_text(path) {
Ok(loaded) => encoding_rs::Encoding::for_label(loaded.encoding.as_bytes()).unwrap_or(encoding_rs::UTF_8),
Err(_) => ide_vfs::detect_encoding(&bytes, None),
};
Ok(Some(encoding.decode(&bytes).0.into_owned()))
}
/// `path` relative to the repository at `root`, with `/` separators.
fn rel_in(root: &Path, path: &Path) -> IdeResult<String> {
let rel = path
.strip_prefix(root)
.map(Path::to_path_buf)
.ok()
.or_else(|| {
// Another spelling of the same place (a link, `/var` and `/private/var`); the file may be gone.
let root = dunce::canonicalize(root).ok()?;
let parent = dunce::canonicalize(path.parent()?).ok()?;
Some(parent.strip_prefix(&root).ok()?.join(path.file_name()?))
})
.ok_or_else(|| IdeError::invalid(format!("{} is outside the repository", path.display())))?;
Ok(rel.components().map(|c| c.as_os_str().to_string_lossy()).collect::<Vec<_>>().join("/"))
}
/// Puts `change` back as it was when the turn `start` began.
pub(crate) fn restore_turn(cwd: &Path, start: &TurnStart, dir: &Path, change: &AgentChange) -> IdeResult<()> {
let repo = repo_at(cwd)?;
put(&change.path.0, at_turn_start(&repo, &change.rel_path, start, dir)?)
}
pub(crate) fn file_at(cwd: &Path, path: &Path, rev: &str) -> IdeResult<Option<String>> {
let Some(repo) = discover(cwd)? else { return Ok(None) };
let encoding = match ide_vfs::load_text(path) {
@@ -815,6 +1001,67 @@ mod tests {
assert!(!created.path.exists());
}
#[test]
fn a_turn_copies_only_what_changed_since_the_last_one() {
let tmp = tempfile::tempdir().unwrap();
let repo = tmp.path().join("repo");
std::fs::create_dir(&repo).unwrap();
git(&repo, &["init", "-q", "-b", "main"]);
std::fs::write(repo.join("a.txt"), "base\n").unwrap();
git(&repo, &["add", "."]);
git(&repo, &["commit", "-q", "-m", "init"]);
let dir = tmp.path().join("turn");
let set = |names: &[&str]| names.iter().map(|n| (*n).to_owned()).collect::<BTreeSet<_>>();
std::fs::write(repo.join("a.txt"), "turn 1\n").unwrap();
std::fs::write(repo.join("b.txt"), "b\n").unwrap();
let first = start_turn(&repo, &dir, None).unwrap();
assert_eq!(first.saved, set(&["a.txt", "b.txt"]));
// A copy made again would replace this mark.
std::fs::write(dir.join(saved_name("b.txt")), "kept\n").unwrap();
std::thread::sleep(std::time::Duration::from_millis(10));
std::fs::write(repo.join("a.txt"), "turn two\n").unwrap();
let second = start_turn(&repo, &dir, Some(&first)).unwrap();
assert_eq!(second.saved, set(&["a.txt", "b.txt"]));
assert_eq!(saved_copy(&dir, "a.txt").as_deref(), Some(&b"turn two\n"[..]));
assert_eq!(saved_copy(&dir, "b.txt").as_deref(), Some(&b"kept\n"[..]));
// Back as committed: nothing to keep a copy of.
git(&repo, &["checkout", "--", "a.txt"]);
let third = start_turn(&repo, &dir, Some(&second)).unwrap();
assert_eq!(third.saved, set(&["b.txt"]));
assert_eq!(saved_copy(&dir, "a.txt"), None);
// Without a record of the last turn (a task from before), every copy is made afresh.
let fresh = start_turn(&repo, &dir, None).unwrap();
assert_eq!(fresh.saved, set(&["b.txt"]));
assert_eq!(saved_copy(&dir, "b.txt").as_deref(), Some(&b"b\n"[..]));
}
#[cfg(unix)]
#[test]
fn a_turns_start_is_found_through_another_spelling_of_the_checkout() {
let tmp = tempfile::tempdir().unwrap();
let repo = dunce::canonicalize(tmp.path()).unwrap().join("repo");
std::fs::create_dir(&repo).unwrap();
git(&repo, &["init", "-q", "-b", "main"]);
std::fs::write(repo.join("a.txt"), "base\n").unwrap();
git(&repo, &["add", "."]);
git(&repo, &["commit", "-q", "-m", "init"]);
std::fs::write(repo.join("a.txt"), "turn 1\n").unwrap();
let dir = tmp.path().join("turn");
let start = start_turn(&repo, &dir, None).unwrap();
std::fs::write(repo.join("a.txt"), "turn 2\n").unwrap();
std::fs::write(repo.join("new.txt"), "new\n").unwrap();
let link = tmp.path().join("link");
std::os::unix::fs::symlink(&repo, &link).unwrap();
for at in [&repo, &link] {
assert_eq!(turn_text(&repo, &at.join("a.txt"), &start, &dir).unwrap().as_deref(), Some("turn 1\n"));
assert_eq!(turn_text(&repo, &at.join("new.txt"), &start, &dir).unwrap(), None);
}
assert!(turn_text(&repo, &tmp.path().join("elsewhere.txt"), &start, &dir).is_err());
}
#[test]
fn commits_since_the_base_are_listed_with_their_files() {
let tmp = tempfile::tempdir().unwrap();
+21 -3
Переглянути файл
@@ -536,7 +536,9 @@ impl PathMap {
let abs = if p.is_absolute() {
p.to_path_buf()
} else {
let in_base = base.map(|b| Path::new(b).join(p)).filter(|c| c.exists());
// rustc prints workspace members' files relative to the workspace root, above
// the member's manifest directory (`base`) when a member is built on its own.
let in_base = base.and_then(|b| Path::new(b).ancestors().map(|a| a.join(p)).find(|c| c.exists()));
in_base.unwrap_or_else(|| cwd.join(p))
};
let abs = normalize(&abs);
@@ -713,7 +715,7 @@ pub fn run(
}
}
};
let out = process::run(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
let out = process::run_bounded(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
let parsed = parser.feed(line);
match parsed.console {
Some(text) if text.is_empty() => {}
@@ -755,7 +757,7 @@ pub fn run(
if !out.success {
success = false;
if !messages.iter().any(|m| m.severity == Severity::Error) {
let summary = crate::sync::error_summary(&out.text);
let summary = crate::sync::error_summary(&out);
let text = if summary.is_empty() { last_error_line.clone() } else { summary };
let m = BuildMessage { severity: Severity::Error, text, path: None, range: None, code: None };
on_event(BuildEvent::Message { message: m.clone() });
@@ -1303,6 +1305,22 @@ mod tests {
assert_eq!(identifier_len("x é_1 c", 2), 3);
}
#[test]
fn resolves_a_member_build_s_workspace_relative_paths() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().to_path_buf();
write(&root, "client/src/main.rs", "fn main() {}\n");
write(&root, "client/src/lib.rs", "\n");
write(&root, "src/lib.rs", "\n");
let map = PathMap { root: root.clone(), canonical: None };
let member = root.join("client");
let base = member.to_str();
// Build Module runs in the member; rustc names its files from the workspace root.
assert_eq!(map.resolve("client/src/main.rs", &member, base), root.join("client/src/main.rs"));
// A crate built from its own directory names them from there.
assert_eq!(map.resolve("src/lib.rs", &member, base), member.join("src/lib.rs"));
}
// Uses Unix absolute paths for the canonical root.
#[cfg(unix)]
#[test]
+1
Переглянути файл
@@ -30,6 +30,7 @@ def processedResources = { Project p, s ->
def describe = { Project p ->
def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
if (p.gradle.parent != null) m.build = identity(p.rootProject)
m.resolvableConfigurations = p.configurations.findAll { it.canBeResolved }.collect { it.name }.sort()
// Gradle 4.x has it as a convention property, not an extension.
def sets = p.extensions.findByName('sourceSets') ?: p.findProperty('sourceSets')
if (sets != null) {
+19
Переглянути файл
@@ -41,6 +41,10 @@ pub struct GradleProject {
/// Project-relative build script, if any.
pub build_file: Option<String>,
pub tasks: Vec<GradleTask>,
/// Configurations Gradle can resolve, or null before Gradle reports the project.
#[serde(default)]
#[specta(optional)]
pub resolvable_configurations: Option<Vec<String>>,
/// Identity path of the nested build holding the project (`:lib` for `includeBuild`,
/// `:buildSrc`); null for the opened build.
#[serde(default)]
@@ -301,6 +305,7 @@ fn project_at(root: &Path, path: String, name: String, pdir: &Path) -> GradlePro
path,
name,
tasks,
resolvable_configurations: None,
build: None,
}
}
@@ -317,6 +322,8 @@ pub struct ReportedProject {
pub build_dir: Option<String>,
#[serde(default)]
pub source_sets: Vec<ReportedSourceSet>,
#[serde(default)]
pub resolvable_configurations: Option<Vec<String>>,
/// Toolchain language version, else target compatibility.
#[serde(default)]
pub java: Option<u32>,
@@ -412,6 +419,7 @@ pub fn merge_reported_projects(root: &Path, model: &mut GradleModel, reported: &
if p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc")) {
project.tasks.clear();
}
project.resolvable_configurations = p.resolvable_configurations.clone();
project.build = p.build.clone();
project
})
@@ -1630,6 +1638,11 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
path: path.into(),
dir: ws.join(d).to_string_lossy().into_owned(),
build: build.map(Into::into),
resolvable_configurations: match path {
":" => Some(vec!["reviewTools".into(), "runtimeClasspath".into()]),
":lib:core" => Some(Vec::new()),
_ => None,
},
..ReportedProject::default()
};
format!("{MODEL_LINE}{}\n", serde_json::to_string(&project).unwrap())
@@ -1658,6 +1671,12 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
);
let build_src = &model.projects[2];
assert!(build_src.tasks.is_empty(), "buildSrc tasks cannot run from the root build");
assert_eq!(
model.projects[0].resolvable_configurations,
Some(vec!["reviewTools".into(), "runtimeClasspath".into()])
);
assert_eq!(model.projects[1].resolvable_configurations, None);
assert_eq!(model.projects[4].resolvable_configurations, Some(Vec::new()));
assert!(!model.projects[4].tasks.is_empty());
assert!(build_files(&root, &model).contains(&ws.join("lib/settings.gradle")));
}
+8 -5
Переглянути файл
@@ -135,7 +135,7 @@ pub fn gradle_dependencies(
configuration: &str,
cancel: &CancellationToken,
) -> IdeResult<Vec<GradleDependency>> {
if !configuration.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-') || configuration.is_empty() {
if configuration.is_empty() || !configuration.chars().all(|c| c.is_alphanumeric() || matches!(c, '_' | '-' | '.')) {
return Err(IdeError::invalid(format!("not a configuration name: {configuration}")));
}
if !project.starts_with(':') || project.chars().any(char::is_whitespace) {
@@ -143,7 +143,7 @@ pub fn gradle_dependencies(
}
let task = if project == ":" { ":dependencies".to_owned() } else { format!("{project}:dependencies") };
let mut args: Vec<String> =
vec!["--console=plain".into(), "-q".into(), task, "--configuration".into(), configuration.into()];
vec!["--console=plain".into(), "-q".into(), task, format!("--configuration={configuration}")];
if options.offline {
args.push("--offline".into());
}
@@ -156,7 +156,10 @@ pub fn gradle_dependencies(
|_, _| {},
)?;
if !out.success {
return Err(IdeError::unavailable(error_summary(&out.text)));
return Err(IdeError::unavailable(error_summary(&out)));
}
if let Some(note) = sync::truncation_note(&out) {
return Err(IdeError::unavailable(note));
}
Ok(parse_report(&out.text))
}
@@ -337,14 +340,14 @@ runtimeClasspath - Runtime classpath of source set 'main'.
&gradle::load(root).unwrap(),
&options,
":app",
"testRuntimeClasspath",
"review.tools",
&CancellationToken::new(),
)
.unwrap();
assert_eq!(tree, vec![dep("org.a", "b", Some("1.0"))]);
assert_eq!(
std::fs::read_to_string(root.join("args")).unwrap().trim(),
"--console=plain -q :app:dependencies --configuration testRuntimeClasspath --offline"
"--console=plain -q :app:dependencies --configuration=review.tools --offline"
);
}
}
+2
Переглянути файл
@@ -13,6 +13,8 @@ pub mod kotlin_bridge;
pub mod maven;
pub mod pom_edit;
mod process;
#[cfg(test)]
mod process_numbers;
pub mod sbt;
mod sync;
pub mod web;
+29 -6
Переглянути файл
@@ -1241,10 +1241,13 @@ fn file_stamp(path: &Path) -> FileStamp {
std::fs::metadata(path).ok().map(|m| (m.modified().ok(), m.len()))
}
/// The POM files a reactor walk read or looked for, and the module folders it found outside the root.
/// The POM files a reactor walk read or looked for, the module folders it found outside the
/// root, and the folders of every project in the reactor (canonical, the root's first).
#[derive(Clone)]
struct ReactorScan {
stamps: Vec<(PathBuf, FileStamp)>,
dirs: Vec<PathBuf>,
members: Vec<PathBuf>,
}
/// Folders of the modules that the reactor of `root/pom.xml` lists outside `root`
@@ -1254,18 +1257,28 @@ struct ReactorScan {
/// Callers keep the outermost directory only. Memoized on the POMs' modification times and
/// sizes: content roots are read on hot paths (every references search, Find in Files).
pub fn reactor_external_dirs(root: &Path, profiles: &[String], unlinked: &[String]) -> Vec<PathBuf> {
reactor(root, profiles, unlinked).dirs
}
/// Folders of every project in the reactor of `root/pom.xml` (canonical): `root` itself and its
/// modules, theirs in turn, including those of the active `profiles`. A POM elsewhere below `root`
/// that no `<module>` reaches is a separate build.
pub fn reactor_member_dirs(root: &Path, profiles: &[String]) -> Vec<PathBuf> {
reactor(root, profiles, &[]).members
}
fn reactor(root: &Path, profiles: &[String], unlinked: &[String]) -> ReactorScan {
type Memo = HashMap<(PathBuf, Vec<String>, Vec<String>), ReactorScan>;
static MEMO: std::sync::LazyLock<Mutex<Memo>> = std::sync::LazyLock::new(Default::default);
let key = (root.to_path_buf(), profiles.to_vec(), unlinked.to_vec());
if let Some(scan) = MEMO.lock().unwrap_or_else(|e| e.into_inner()).get(&key)
&& scan.stamps.iter().all(|(path, stamp)| file_stamp(path) == *stamp)
{
return scan.dirs.clone();
return scan.clone();
}
let scan = scan_reactor(root, profiles, unlinked);
let dirs = scan.dirs.clone();
MEMO.lock().unwrap_or_else(|e| e.into_inner()).insert(key, scan);
dirs
MEMO.lock().unwrap_or_else(|e| e.into_inner()).insert(key, scan.clone());
scan
}
/// Reads only the POMs the reactor lists (no parent resolution and no directory walk).
@@ -1274,7 +1287,8 @@ fn scan_reactor(root: &Path, profiles: &[String], unlinked: &[String]) -> Reacto
let chosen = Resolver::new(None, profiles);
let unlinked: HashSet<String> = unlinked.iter().map(|p| normalized_pom(p.trim())).collect();
let first = root.join("pom.xml");
let mut scan = ReactorScan { stamps: vec![(first.clone(), file_stamp(&first))], dirs: Vec::new() };
let mut scan =
ReactorScan { stamps: vec![(first.clone(), file_stamp(&first))], dirs: Vec::new(), members: Vec::new() };
let mut seen: HashSet<PathBuf> = HashSet::new();
let mut pending = vec![first];
while let Some(path) = pending.pop() {
@@ -1288,6 +1302,7 @@ fn scan_reactor(root: &Path, profiles: &[String], unlinked: &[String]) -> Reacto
let Some(pom) = xml::read_text(&path).as_deref().and_then(parse_pom) else { continue };
let dir = path.parent().unwrap_or(root).to_path_buf();
let dir_canon = dunce::canonicalize(&dir).unwrap_or_else(|_| dir.clone());
scan.members.push(dir_canon.clone());
if !dir_canon.starts_with(&canonical_root) {
if canonical_root.starts_with(&dir_canon) {
continue;
@@ -1860,6 +1875,14 @@ pub fn goto_declaration(text: &str, path: &Path, pos: Pos, local_repo: Option<Pa
goto_declaration_in(text, path, pos, local_repo, Vec::new)
}
/// The declaration of the property `name` in the pom at `path`, for files it configures
/// outside the pom itself (a YAML resource's `@name@`): the first `<properties>` entry
/// along the parent chain declaring it, `project.*` built-ins included.
pub fn property_declaration(pom: &Path, name: &str, local_repo: Option<PathBuf>) -> Option<PomGoto> {
let text = xml::read_text(pom)?;
property_target(&text, pom, name, local_repo)
}
/// [`goto_declaration`], where a `<parent>` and a dependency or plugin whose version no
/// management entry provides (or a management entry itself) go to the artifact's own
/// POM: the project module among `modules` with its coordinates, else the local
+337 -19
Переглянути файл
@@ -17,10 +17,72 @@ pub(crate) enum Stream {
Stderr,
}
/// A single line longer than this without a newline is delivered as several lines: the pump
/// buffer stays bounded whatever the child prints (progress bars, minified bundles, binary
/// output), and every byte still arrives.
pub(crate) const MAX_LINE_BYTES: usize = 1024 * 1024;
/// `Output::text` stops growing past this while the pipes keep draining: a chatty build can
/// print far more than is ever parsed back out of the retained copy.
pub(crate) const MAX_TEXT_BYTES: usize = 32 * 1024 * 1024;
pub(crate) struct Output {
pub success: bool,
/// Every line, stdout and stderr interleaved as received.
/// Every line, stdout and stderr interleaved as received, up to [`MAX_TEXT_BYTES`].
pub text: String,
/// More output followed the retained `text`; the lines were still fed to `on_line`.
pub truncated: bool,
}
/// Bounded pump for callers that stream every line and only summarize errors: reads fixed
/// 64 KiB chunks, splits newline-free runs at a UTF-8 char boundary at the line cap, and
/// never grows one line buffer without bound.
fn pump_bounded(stream: Box<dyn Read + Send>, kind: Stream, tx: &mpsc::Sender<(Stream, String)>) {
let mut reader = BufReader::new(stream);
// `terminated`: the buffer ends in the stream's newline. A segment cut from a
// newline-free run at the line cap must keep a trailing `\r` — it is data.
let send = |buf: &mut Vec<u8>, terminated: bool, tx: &mpsc::Sender<(Stream, String)>| {
let line = ide_core::output_encoding::decode_tool_output(buf);
let line = if terminated { line.trim_end_matches(['\n', '\r']).to_owned() } else { line };
buf.clear();
tx.send((kind, line)).is_ok()
};
let mut chunk = vec![0u8; 64 * 1024];
let mut line: Vec<u8> = Vec::with_capacity(256);
'read: loop {
let n = match reader.read(&mut chunk) {
Ok(0) | Err(_) => break,
Ok(n) => n,
};
let mut start = 0;
for (i, &b) in chunk[..n].iter().enumerate() {
if b == b'\n' {
line.extend_from_slice(&chunk[start..=i]);
if !send(&mut line, true, tx) {
break 'read;
}
start = i + 1;
}
}
line.extend_from_slice(&chunk[start..n]);
while line.len() > MAX_LINE_BYTES {
let mut at = MAX_LINE_BYTES;
while at > 0 && line[at] & 0xC0 == 0x80 {
at -= 1;
}
// Malformed input with no boundary at all: split raw and let decoding say so.
if at == 0 {
at = MAX_LINE_BYTES;
}
let rest = line.split_off(at);
if !send(&mut line, false, tx) {
break 'read;
}
line = rest;
}
}
if !line.is_empty() {
send(&mut line, true, tx);
}
}
/// `program` as spawnable: a bare name (`mvn`, `mvn.cmd`) resolves on the IDE's
@@ -41,7 +103,8 @@ pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>, cwd: &
}
/// Runs `program args` in `cwd`, feeding each output line to `on_line`; kills
/// the process group and returns `cancelled` when `cancel` fires.
/// the process group and returns `cancelled` when `cancel` fires. `Output.text`
/// keeps every line: callers that parse a complete model from it use this.
pub(crate) fn run(
program: &str,
args: &[String],
@@ -53,6 +116,20 @@ pub(crate) fn run(
run_with_env(program, args, cwd, env, false, cancel, on_line)
}
/// Like [`run`], but bounds both the per-line buffer and the retained copy. For callers
/// that stream every line to `on_line` and use `Output.text` only for error summaries:
/// sync/model listings must be kept whole and use [`run`] instead.
pub(crate) fn run_bounded(
program: &str,
args: &[String],
cwd: &Path,
env: &BTreeMap<String, String>,
cancel: &CancellationToken,
on_line: impl FnMut(Stream, &str),
) -> IdeResult<Output> {
run_with_env_capture(program, args, cwd, env, RunOptions { bounded: true, ..Default::default() }, cancel, on_line)
}
pub(crate) fn run_with_env(
program: &str,
args: &[String],
@@ -60,8 +137,27 @@ pub(crate) fn run_with_env(
env: &BTreeMap<String, String>,
clear_env: bool,
cancel: &CancellationToken,
on_line: impl FnMut(Stream, &str),
) -> IdeResult<Output> {
run_with_env_capture(program, args, cwd, env, RunOptions { clear_env, ..Default::default() }, cancel, on_line)
}
#[derive(Clone, Copy, Default)]
struct RunOptions {
clear_env: bool,
bounded: bool,
}
fn run_with_env_capture(
program: &str,
args: &[String],
cwd: &Path,
env: &BTreeMap<String, String>,
options: RunOptions,
cancel: &CancellationToken,
mut on_line: impl FnMut(Stream, &str),
) -> IdeResult<Output> {
let RunOptions { clear_env, bounded } = options;
tracing::info!("build: {program} {} (in {})", args.join(" "), cwd.display());
// Output is read as UTF-8: JVMs on Windows are told to write it (see `ide_core::output_encoding`).
let encoding =
@@ -80,17 +176,22 @@ pub(crate) fn run_with_env(
let (tx, rx) = mpsc::channel::<(Stream, String)>();
let pump = |stream: Box<dyn Read + Send>, kind: Stream, tx: mpsc::Sender<(Stream, String)>| {
std::thread::spawn(move || {
let mut reader = BufReader::new(stream);
let mut buf = Vec::new();
loop {
buf.clear();
match reader.read_until(b'\n', &mut buf) {
Ok(0) | Err(_) => break,
Ok(_) => {
let line = ide_core::output_encoding::decode_tool_output(&buf);
let line = line.trim_end_matches(['\n', '\r']).to_owned();
if tx.send((kind, line)).is_err() {
break;
if bounded {
pump_bounded(stream, kind, &tx);
} else {
// Model listings are parsed from Output.text: keep every line whole, however long.
let mut reader = BufReader::new(stream);
let mut buf = Vec::new();
loop {
buf.clear();
match reader.read_until(b'\n', &mut buf) {
Ok(0) | Err(_) => break,
Ok(_) => {
let line = ide_core::output_encoding::decode_tool_output(&buf);
let line = line.trim_end_matches(['\n', '\r']).to_owned();
if tx.send((kind, line)).is_err() {
break;
}
}
}
}
@@ -102,7 +203,17 @@ pub(crate) fn run_with_env(
child.stderr.take().map(|s| pump(Box::new(s), Stream::Stderr, tx.clone())),
];
drop(tx);
let mut text = String::new();
// Retained copy of the output: the first half of the cap, then — once output overflows —
// a rolling tail instead of the middle. Error summaries read the end of the output, while
// listings parsed out of a successful run read from the start. The pipes keep draining
// either way: `on_line` still sees every line, so the child never blocks on a full pipe.
let cap = MAX_TEXT_BYTES / 2;
let mut head = String::new();
let mut tail: std::collections::VecDeque<Vec<u8>> = Default::default();
let mut chunk: Vec<u8> = Vec::new();
let mut tail_bytes = 0usize;
let mut total = 0usize;
let mut truncated = false;
loop {
if cancel.is_cancelled() {
kill_tree(&mut child);
@@ -112,8 +223,34 @@ pub(crate) fn run_with_env(
Ok((_, line)) if encoding.notice.as_ref() == Some(&line) => {}
Ok((stream, line)) => {
on_line(stream, &line);
text.push_str(&line);
text.push('\n');
if !bounded {
// The caller parses a complete model from `text`, so keep every line.
head.push_str(&line);
head.push('\n');
continue;
}
total += line.len() + 1;
if !truncated {
if head.len() + line.len() < cap {
head.push_str(&line);
head.push('\n');
continue;
}
truncated = true;
}
// Fixed-size chunks, not per-line buffers: a chatty build pushes millions of
// lines past the cap, and the tail must add no allocation per line.
chunk.extend_from_slice(line.as_bytes());
chunk.push(b'\n');
if chunk.len() >= 64 * 1024 {
tail_bytes += chunk.len();
tail.push_back(std::mem::take(&mut chunk));
chunk.reserve_exact(64 * 1024);
while tail_bytes > cap {
let Some(front) = tail.pop_front() else { break };
tail_bytes -= front.len();
}
}
}
Err(mpsc::RecvTimeoutError::Timeout) => {}
Err(mpsc::RecvTimeoutError::Disconnected) => break,
@@ -123,13 +260,85 @@ pub(crate) fn run_with_env(
let _ = r.join();
}
let status = child.wait()?;
Ok(Output { success: status.success(), text })
let mut text = head;
if truncated {
if !chunk.is_empty() {
tail_bytes += chunk.len();
tail.push_back(std::mem::take(&mut chunk));
}
// The last partial chunk may sit past the cap; drop whole front chunks back under it.
while tail_bytes > cap {
let Some(front) = tail.pop_front() else { break };
tail_bytes -= front.len();
}
// Tail chunks are flushed only right after a completed line, so the tail always begins
// at a line boundary — no leading fragment to drop.
let tail = ide_core::output_encoding::decode_tool_output(&tail.into_iter().flatten().collect::<Vec<u8>>());
let omitted = total.saturating_sub(text.len() + tail.len());
if omitted == 0 {
// Everything that overflowed the head still fits in the tail: nothing was lost.
truncated = false;
} else {
text.push_str(&format!("[{omitted} bytes of build output between these lines were not retained]\n"));
}
text.push_str(&tail);
}
Ok(Output { success: status.success(), text, truncated })
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_model_line_over_one_mebibyte_is_kept_whole_for_the_parsers() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// A Gradle MODEL_LINE JSON line longer than the bounded pump's 1 MiB line cap,
// surrounded by ordinary output.
let script = "echo start; head -c 1048576 /dev/zero | tr '\\0' a; printf '\\n{\"id\":\"big\"}\\n'; echo end";
let mut lines = Vec::new();
let out = run(
"sh",
&["-c".into(), script.into()],
tmp.path(),
&BTreeMap::new(),
&CancellationToken::new(),
|_, line| lines.push(line.to_owned()),
)
.unwrap();
assert!(out.success);
assert!(!out.truncated);
// The long line is one line, not segments that a JSON-line parser would skip.
assert_eq!(lines.len(), 4);
assert_eq!(lines[1].len(), 1_048_576);
assert!(out.text.contains("{\"id\":\"big\"}"));
let models: Vec<serde_json::Value> = out.text.lines().filter_map(|l| serde_json::from_str(l).ok()).collect();
assert_eq!(models.len(), 1, "the model line must survive full retention");
}
#[test]
fn a_successful_report_over_the_text_cap_is_retained_in_full() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
let args = ["-c".into(), r"awk 'BEGIN{for(i=1;i<=6000000;i++)print i}'".into()];
let mut fed = 0usize;
let out = run("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
fed += line.len() + 1;
})
.unwrap();
assert!(out.success);
assert!(!out.truncated);
// Every line of a large successful dependency/model report is still there.
assert_eq!(out.text.len(), fed);
assert!(out.text.starts_with("1\n"));
assert!(out.text.ends_with("6000000\n"));
}
#[test]
fn runs_and_cancels_processes() {
if cfg!(windows) {
@@ -148,10 +357,11 @@ mod tests {
)
.unwrap();
assert!(!out.success);
assert!(!out.truncated);
lines.sort_by(|a, b| a.1.cmp(&b.1));
assert_eq!(lines, [(Stream::Stdout, "one".to_owned()), (Stream::Stderr, "two".to_owned())]);
cancel.cancel();
let err = run("sh", &["-c".into(), "sleep 5".into()], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {})
let err = run_bounded("sh", &["-c".into(), "sleep 5".into()], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {})
.err()
.unwrap();
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
@@ -171,9 +381,117 @@ mod tests {
std::thread::sleep(Duration::from_millis(200));
c.cancel();
});
let err = run("sh", &["-c".into(), script], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {}).err().unwrap();
let err =
run_bounded("sh", &["-c".into(), script], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {}).err().unwrap();
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
std::thread::sleep(Duration::from_millis(1300));
assert!(!marker.exists(), "the background child must be killed with the group");
}
#[test]
fn output_past_the_text_cap_keeps_head_and_tail_and_drains() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// Numbered lines 1..=6,000,000 ≈ 45 MB: past the 32 MiB retained cap.
let args = ["-c".into(), r"awk 'BEGIN{for(i=1;i<=6000000;i++)print i}'".into()];
let mut fed = 0usize;
let mut last_seen = String::new();
let out = run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
fed += line.len() + 1;
last_seen = line.to_owned();
})
.unwrap();
assert!(out.success);
assert!(out.truncated);
// The pipes drained to the end: the callback saw the last line.
assert_eq!(last_seen, "6000000");
assert_eq!(fed, out_success_bytes());
// The retained copy is bounded, keeps the head and the tail, and says what was dropped.
assert!(out.text.len() <= MAX_TEXT_BYTES + 128, "{}", out.text.len());
assert!(out.text.starts_with("1\n"));
assert!(out.text.ends_with("6000000\n"));
assert!(out.text.contains("were not retained]"));
assert!(!out.text.contains("\n3000000\n"), "a middle line must be the dropped part");
}
/// Lines `1..=6_000_000` emit exactly this many bytes (digit count + newline each).
fn out_success_bytes() -> usize {
(1..=6_000_000u64).map(|n| n.checked_ilog10().unwrap() as usize + 2).sum()
}
#[test]
fn a_newline_free_run_longer_than_the_line_cap_arrives_as_split_lines() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// 2.5 MiB of `x` without a single newline.
let args = ["-c".into(), "head -c 2621440 /dev/zero | tr '\\0' x".into()];
let mut lines = Vec::new();
let out = run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
lines.push(line.to_owned())
})
.unwrap();
assert!(out.success);
assert!(!out.truncated);
// Split at the cap, not dropped: the segments carry every byte and none is unbounded.
assert!(lines.len() >= 3, "{}", lines.len());
assert_eq!(lines.iter().map(String::len).sum::<usize>(), 2_621_440);
assert!(lines.iter().all(|l| l.len() <= MAX_LINE_BYTES));
}
#[test]
fn a_line_split_never_cuts_a_multibyte_character() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// `x` up to one byte before the 1 MiB cap, then `é` (two bytes) straddling it, then more `x`.
let script =
"head -c 1048575 /dev/zero | tr '\\0' x; printf '\\303\\251'; head -c 1048575 /dev/zero | tr '\\0' x";
let mut lines = Vec::new();
let out = run_bounded(
"sh",
&["-c".into(), script.into()],
tmp.path(),
&BTreeMap::new(),
&CancellationToken::new(),
|_, line| lines.push(line.to_owned()),
)
.unwrap();
assert!(out.success);
// The é straddles the 1 MiB split point: segments shift to keep it whole.
assert!(lines.len() >= 2, "{}", lines.len());
// The character survived the split: present whole, never as U+FFFD halves.
assert!(lines.iter().any(|l| l.contains('é')));
assert!(lines.iter().all(|l| !l.contains('\u{FFFD}')));
assert_eq!(lines.iter().map(String::len).sum::<usize>(), 1_048_575 + 2 + 1_048_575);
}
#[test]
fn output_just_past_the_head_cap_loses_nothing() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
// 4-byte `pad` lines up to just past the 16 MiB head cap, then the real last line:
// the overflow fits the tail whole, so nothing is dropped and nothing is marked.
let script = "yes pad | head -c 16777213; echo 'FATAL: the real error'";
let out = run_bounded(
"sh",
&["-c".into(), script.into()],
tmp.path(),
&BTreeMap::new(),
&CancellationToken::new(),
|_, _| {},
)
.unwrap();
assert!(out.success);
assert!(!out.truncated);
assert!(!out.text.contains("were not retained]"));
assert!(out.text.starts_with("pad\n"));
assert!(out.text.ends_with("FATAL: the real error\n"));
}
}
+36
Переглянути файл
@@ -0,0 +1,36 @@
//! Timed evidence for the bounded build-output capture (issue #3936). Not an assertion:
//! run it on both revisions of `process.rs` and compare the printed numbers.
//!
//! ```text
//! cargo test -p ide-build --release --lib -- --ignored --nocapture numbers
//! ```
use crate::process;
use ide_core::CancellationToken;
use std::collections::BTreeMap;
use std::time::Instant;
/// 256 MiB of 17-byte lines from `yes`, drained by `process::run` with a counting callback.
#[test]
#[ignore = "prints elapsed time and retained bytes; see the module docs"]
fn high_output_process_numbers() {
if cfg!(windows) {
return;
}
let tmp = tempfile::tempdir().unwrap();
let args = ["-c".into(), "yes 0123456789abcdef | head -c 268435456".into()];
let start = Instant::now();
let mut lines = 0u64;
let mut fed = 0usize;
let out = process::run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
lines += 1;
fed += line.len() + 1;
})
.unwrap();
println!(
"elapsed {:?} | success {} | retained {} bytes | fed {lines} lines / {fed} bytes",
start.elapsed(),
out.success,
out.text.len()
);
}
+40 -8
Переглянути файл
@@ -268,8 +268,20 @@ fn run(
process::run(program, args, cwd, env, cancel, |_, line| on_line(line))
}
/// What a sync records when a *successful* child run's output was truncated: parsing a
/// truncated listing would silently produce an incomplete model, so it is surfaced, not hidden.
pub(crate) fn truncation_note(out: &Output) -> Option<String> {
out.truncated.then(|| {
format!(
"the build printed more than the retained {} MiB of output; the model may be incomplete",
crate::process::MAX_TEXT_BYTES / (1024 * 1024)
)
})
}
/// The first error lines of a failed build, for the tool window.
pub(crate) fn error_summary(text: &str) -> String {
pub(crate) fn error_summary(output: &Output) -> String {
let text = &output.text;
// The JVM's "could not find or load main class" (localized) when `gradlew` has no jar.
if text.contains("org.gradle.wrapper.GradleWrapperMain") {
return "gradle/wrapper/gradle-wrapper.jar is missing (often excluded by a `*.jar` rule in .gitignore). \
@@ -289,11 +301,15 @@ pub(crate) fn error_summary(text: &str) -> String {
.filter(|l| !l.is_empty() && !l.starts_with("Re-run Maven") && !l.starts_with("To see the full stack trace"))
.take(4)
.collect();
if lines.is_empty() {
let mut summary = if lines.is_empty() {
text.lines().rev().find(|l| !l.trim().is_empty()).unwrap_or("the build failed").trim().to_owned()
} else {
lines.join("\n")
};
if output.truncated {
summary.push_str("\n[the build printed more than the retained output; this summary may miss lines]");
}
summary
}
/// `[INFO] Building core 1.0-SNAPSHOT [2/3]` → ("core 1.0-SNAPSHOT", 2, 3).
@@ -397,7 +413,9 @@ pub fn sync_maven(
}
}
if !out.success {
errors.push(error_summary(&out.text));
errors.push(error_summary(&out));
} else if let Some(note) = truncation_note(&out) {
errors.push(note);
}
}
cache.at_ms = now_ms();
@@ -437,6 +455,8 @@ pub fn sync_gradle_model(
let mut args: Vec<String> = vec![
"--console=plain".into(),
"-q".into(),
// The init script reports the evaluated projects, even when a build enables the configuration cache.
"-Dorg.gradle.configuration-cache=false".into(),
"--init-script".into(),
init_script.to_string_lossy().into_owned(),
"tasks".into(),
@@ -457,7 +477,7 @@ pub fn sync_gradle_model(
Ok(out) => out,
Err(_) if cancel.is_cancelled() => return Err(IdeError::cancelled()),
Err(error) if error.kind == ide_core::error::ErrorKind::Unavailable => {
Output { success: false, text: error.message }
Output { success: false, text: error.message, truncated: false }
}
Err(error) => return Err(error),
};
@@ -470,7 +490,7 @@ pub fn sync_gradle_model(
let cache = GradleCache {
hash: hash_gradle_files(&gradle::build_files(root, &model)),
at_ms: now_ms(),
error: (!out.success).then(|| error_summary(&out.text)),
error: if !out.success { Some(error_summary(&out)) } else { truncation_note(&out) },
tasks: if out.success { gradle::parse_tasks(&out.text) } else { Vec::new() },
projects,
resources: true,
@@ -914,10 +934,22 @@ mod tests {
);
assert_eq!(maven_building("[INFO] Building jar: x.jar"), None);
let text = "[INFO] x\n[ERROR] Failed to execute goal\n[ERROR] \n[ERROR] Re-run Maven using -X\n";
assert_eq!(error_summary(text), "Failed to execute goal");
assert_eq!(error_summary("one\nlast line\n\n"), "last line");
let out = |text: &str, truncated| crate::process::Output { success: false, text: text.to_owned(), truncated };
assert_eq!(error_summary(&out(text, false)), "Failed to execute goal");
assert_eq!(error_summary(&out("one\nlast line\n\n", false)), "last line");
let missing_jar = "错误: 找不到或无法加载主类 org.gradle.wrapper.GradleWrapperMain\n";
assert!(error_summary(missing_jar).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
assert!(error_summary(&out(missing_jar, false)).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
// A truncated capture says so instead of hiding that lines are missing.
assert!(error_summary(&out(text, true)).ends_with("this summary may miss lines]"));
}
#[test]
fn a_truncated_successful_run_is_surfaced_not_silent() {
let out = |truncated| crate::process::Output { success: true, text: String::new(), truncated };
assert!(truncation_note(&out(false)).is_none());
let note = truncation_note(&out(true)).unwrap();
assert!(note.starts_with("the build printed more than the retained 32 MiB"), "{note}");
assert!(note.ends_with("the model may be incomplete"));
}
#[test]
+6
Переглянути файл
@@ -446,6 +446,12 @@ pub struct LanguageCodeStyle {
/// Comment Code › Add a space at line comment start.
#[serde(skip_serializing_if = "Option::is_none")]
pub line_comment_add_space: Option<bool>,
/// PHP: align `=>` in multi-line arrays after formatting (other languages ignore it).
#[serde(skip_serializing_if = "Option::is_none")]
pub align_key_value_pairs: Option<bool>,
/// PHP: align `=` of consecutive assignment statements after formatting.
#[serde(skip_serializing_if = "Option::is_none")]
pub align_consecutive_assignments: Option<bool>,
}
/// Editor › Code Style (General tab + per-language overrides).
+5 -3
Переглянути файл
@@ -1062,11 +1062,13 @@ mod tests {
#[test]
fn a_child_inside_a_project_gets_its_environment() {
let root = std::path::Path::new("/openidea-test-process/project");
// Absolute on the platform: the search path drops relative entries.
let devshell = if cfg!(windows) { r"C:\nix\store\x-devshell\bin" } else { "/nix/store/x-devshell/bin" };
crate::project_env::set(
root,
vec![
("OPENIDEA_PROJECT_VAR".into(), Some("devshell".into())),
("PATH".into(), Some("/nix/store/x-devshell/bin".into())),
("PATH".into(), Some(devshell.into())),
("OPENIDEA_PROJECT_UNSET".into(), None),
],
);
@@ -1075,7 +1077,7 @@ mod tests {
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, "PATH"), Some(Some(devshell.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");
@@ -1093,7 +1095,7 @@ mod tests {
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()));
assert_eq!(std::env::split_paths(&search).next(), Some(devshell.into()));
crate::project_env::remove(root);
assert!(host_vars_in(root).all(|(k, _)| k != "OPENIDEA_PROJECT_VAR"));
}
+4
Переглянути файл
@@ -1504,6 +1504,10 @@ pub struct MavenSettings {
pub active_profiles: String,
/// Delegate IDE build/run actions to Maven: launches build with Maven (`javac`) instead of jdtls (ECJ).
pub delegate_build: bool,
/// Download `-sources.jar` of dependencies when the Java language server imports the
/// project (jdtls `java.maven.downloadSources`). Off: sources are fetched on demand
/// from a library class's Download Sources banner.
pub download_sources: bool,
}
impl MavenSettings {
+42 -6
Переглянути файл
@@ -912,7 +912,7 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
/// A `runInTerminal` program and the pseudo-terminal it runs in.
pub(crate) struct ProgramTerminal {
writer: ide_core::input::InputWriter,
writer: Arc<ide_core::input::InputWriter>,
killer: Box<dyn portable_pty::ChildKiller + Send + Sync>,
#[cfg_attr(not(unix), allow(dead_code))]
pid: Option<u32>,
@@ -1025,10 +1025,12 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
let _ = child.wait();
})
.map_err(|e| format!("terminal input worker: {e}"))?;
let writer = Arc::new(writer);
let pid = child.process_id();
forward_terminal_output(
s,
reader,
writer.clone(),
#[cfg(unix)]
wait_readable,
);
@@ -1043,10 +1045,35 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
Ok(json!({ "processId": pid }))
}
/// The program's terminal output, as stdout lines (`\r\n` as `\n`; colours are kept).
/// A terminal's cursor position query (DSR). ConPTY sends one when it starts and runs the program
/// only once the terminal answers; programs that lay out a prompt ask it too.
const CURSOR_QUERY: &[u8] = b"\x1b[6n";
/// `chunk` without its cursor position queries, and how many there were.
pub(crate) fn take_cursor_queries(chunk: &[u8]) -> (Vec<u8>, usize) {
let mut out = Vec::with_capacity(chunk.len());
let mut queries = 0;
let mut rest = chunk;
while let Some(at) = rest.windows(CURSOR_QUERY.len()).position(|w| w == CURSOR_QUERY) {
out.extend_from_slice(&rest[..at]);
rest = &rest[at + CURSOR_QUERY.len()..];
queries += 1;
}
out.extend_from_slice(rest);
(out, queries)
}
/// Length of the end of `pending` that may begin a cursor position query the next read completes.
pub(crate) fn partial_cursor_query(pending: &[u8]) -> usize {
(1..CURSOR_QUERY.len()).rev().find(|&n| pending.ends_with(&CURSOR_QUERY[..n])).unwrap_or(0)
}
/// The program's terminal output, as stdout lines (`\r\n` as `\n`; colours are kept). The debug
/// console is no terminal, so cursor position queries are answered here (top-left corner).
fn forward_terminal_output(
s: &Session,
mut reader: Box<dyn std::io::Read + Send>,
answer: Arc<ide_core::input::InputWriter>,
#[cfg(unix)] mut wait_readable: impl FnMut() -> std::io::Result<()> + Send + 'static,
) {
let session = s.id;
@@ -1078,11 +1105,20 @@ fn forward_terminal_output(
break;
}
}
// Keep incomplete UTF-8 sequences, and a `\r` that may start a `\r\n`, for the next chunk.
let mut valid = match std::str::from_utf8(&pending) {
Ok(_) => pending.len(),
let (rest, queries) = take_cursor_queries(&pending);
pending = rest;
for _ in 0..queries {
if let Err(e) = answer.write(b"\x1b[1;1R") {
tracing::warn!(%session, "debug terminal cursor position: {e}");
}
}
// Keep incomplete UTF-8 sequences, a `\r` that may start a `\r\n`, and the start of
// a cursor position query for the next chunk.
let keep = partial_cursor_query(&pending);
let mut valid = match std::str::from_utf8(&pending[..pending.len() - keep]) {
Ok(_) => pending.len() - keep,
Err(e) if e.error_len().is_none() => e.valid_up_to(),
Err(_) => pending.len(),
Err(_) => pending.len() - keep,
};
if valid > 0 && pending[valid - 1] == b'\r' {
valid -= 1;
+38
Переглянути файл
@@ -1010,6 +1010,44 @@ async fn run_in_terminal_spawns_debuggee() {
assert!(response["body"]["processId"].as_u64().unwrap() > 0);
}
/// The debug console answers a terminal's cursor position query: ConPTY asks one before it runs
/// the program at all (Windows debuggees never started), and programs that lay out a prompt ask too.
#[tokio::test]
async fn run_in_terminal_answers_cursor_position_queries() {
#[cfg(unix)]
let program = vec![
"sh".into(),
"-c".into(),
r"stty -echo -icanon min 6; printf '\033[6n'; reply=$(dd bs=6 count=1 2>/dev/null); stty sane; case $reply in *'[1;1R') echo answered;; esac".into(),
];
#[cfg(windows)]
let program = vec!["cmd".into(), "/c".into(), "echo answered".into()];
let h = harness(Script { run_in_terminal: Some(program), ..Script::default() });
h.start(config()).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Output { output, .. } if output.contains("answered"))).await;
let output: String = h
.events
.lock()
.iter()
.filter_map(|e| match e {
IdeEvent::Debug { event: DebugEvent::Output { output, .. }, .. } => Some(output.clone()),
_ => None,
})
.collect();
assert!(!output.contains("\x1b[6n"), "{output:?}");
}
#[test]
fn cursor_position_queries_are_taken_out_of_the_output() {
use crate::session::{partial_cursor_query, take_cursor_queries};
assert_eq!(take_cursor_queries(b"a\x1b[6nb\x1b[6n"), (b"ab".to_vec(), 2));
assert_eq!(take_cursor_queries(b"\x1b[0mtext"), (b"\x1b[0mtext".to_vec(), 0));
assert_eq!(partial_cursor_query(b"text\x1b["), 2);
assert_eq!(partial_cursor_query(b"text\x1b[6"), 3);
assert_eq!(partial_cursor_query(b"text\x1b[0m"), 0);
assert_eq!(partial_cursor_query(b"text"), 0);
}
#[cfg(unix)]
#[tokio::test]
async fn run_in_terminal_program_reads_typed_input() {
+336 -31
Переглянути файл
@@ -18,14 +18,21 @@ struct State {
database: String,
settings: Vec<(String, String)>,
read_only: bool,
session_id: String,
session: Mutex<bool>,
session: Mutex<Session>,
closed: CancellationToken,
}
#[derive(Default)]
struct Session {
id: Option<String>,
initialized: bool,
strict_read_only: bool,
}
/// The response format: a names line, a types line, then one JSON array per row, so rows past
/// the grid's limit are skipped without being parsed.
const FORMAT: &str = "JSONCompactEachRowWithNamesAndTypes";
const SESSION_LOST: &str = "ClickHouse HTTP session not found on this node (code 372). Use one node or session affinity, or set use_http_session=false in Advanced for independent queries.";
pub(crate) fn transaction_error() -> IdeError {
IdeError::invalid("ClickHouse HTTP does not support SQL transactions; use auto-commit and run writes directly")
@@ -36,11 +43,32 @@ impl ClickhousePool {
if source.options.transaction == DbTxMode::Manual {
return Err(transaction_error());
}
for (name, _) in &setup.params {
if reserved_setting(name) {
let mut use_http_session = None;
let mut settings = Vec::with_capacity(setup.params.len());
for (name, value) in setup.params {
if name.eq_ignore_ascii_case("use_http_session") {
if use_http_session.is_some() {
return Err(IdeError::invalid("ClickHouse use_http_session must be specified only once"));
}
use_http_session = Some(if value.eq_ignore_ascii_case("true") {
true
} else if value.eq_ignore_ascii_case("false") {
false
} else {
return Err(IdeError::invalid("ClickHouse use_http_session must be true or false"));
});
} else if reserved_setting(&name) {
return Err(IdeError::invalid(format!("ClickHouse HTTP manages the {name} setting")));
} else {
settings.push((name, value));
}
}
let use_http_session = use_http_session.unwrap_or(true);
if !use_http_session && (!setup.statements.is_empty() || !source.options.startup_script.trim().is_empty()) {
return Err(IdeError::invalid(
"ClickHouse use_http_session=false does not support startup scripts; configure database and settings on the data source for each request",
));
}
let secure = matches!(source.ssl, DbSslMode::Require | DbSslMode::VerifyCa | DbSslMode::VerifyFull);
let tls_files = [&source.ssl_ca_file, &source.ssl_cert_file, &source.ssl_key_file];
if !secure && tls_files.iter().any(|p| !p.trim().is_empty()) {
@@ -106,15 +134,49 @@ impl ClickhousePool {
user: if source.user.is_empty() { "default".into() } else { source.user.clone() },
password: password.unwrap_or_default().to_owned(),
database: if database.is_empty() { "default".into() } else { database.into() },
settings: setup.params,
settings,
read_only: source.read_only,
session_id: uuid::Uuid::new_v4().to_string(),
session: Mutex::new(false),
session: Mutex::new(Session {
id: use_http_session.then(|| uuid::Uuid::new_v4().to_string()),
..Session::default()
}),
closed: CancellationToken::new(),
}));
let cancel = CancellationToken::new();
let initialize = async {
pool.execute("SELECT 1", 1, &cancel).await?;
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
if !rejects_driver_setting(&error) {
return Err(error);
}
if !use_http_session {
return Err(IdeError::new(
error.kind,
format!(
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
error.message
),
));
}
// Retry only the connection probe. Keep relying on the server for write protection
// only after verifying strict read-only mode in this same session.
{
let mut session = pool.0.session.lock().await;
// Start the proof in a fresh session: the rejected probe may have left
// its id on another replica without applying the configured database.
session.id = Some(uuid::Uuid::new_v4().to_string());
session.strict_read_only = true;
}
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
return Err(error);
}
}
// The HTTP database parameter applies to one request. A named session needs
// USE once so later queries inherit the selection (and may change it).
if use_http_session && !database.is_empty() {
let name = crate::sql::quote_ident(crate::DbDriver::Clickhouse, database);
pool.execute(&format!("USE {name}"), 0, &cancel).await?;
}
for sql in setup.statements {
pool.execute(&sql, 0, &cancel).await?;
}
@@ -151,27 +213,30 @@ impl ClickhousePool {
}
/// `max_rows`: the rows the server may send (the skipped ones included).
fn request(&self, client: &Client, query_id: &str, max_rows: usize, initialized: bool) -> RequestBuilder {
fn request(&self, client: &Client, query_id: &str, max_rows: usize, session: &Session) -> RequestBuilder {
let mut request = client
.post(self.0.endpoint.clone())
.basic_auth(&self.0.user, Some(&self.0.password))
.header(reqwest::header::CONTENT_TYPE, "text/plain; charset=utf-8")
.query(&self.0.settings)
.query(&[
("session_id", self.0.session_id.clone()),
("session_timeout", "3600".into()),
("query_id", query_id.to_owned()),
("default_format", FORMAT.into()),
.query(&[("query_id", query_id), ("default_format", FORMAT)]);
if !session.strict_read_only {
request = request.query(&[
("output_format_json_quote_denormals", "1".into()),
("max_result_rows", max_rows.saturating_add(1).to_string()),
("result_overflow_mode", "break".into()),
]);
if initialized {
request = request.query(&[("session_check", "1")]);
} else {
}
if let Some(session_id) = &session.id {
request = request.query(&[("session_id", session_id.as_str()), ("session_timeout", "3600")]);
if session.initialized {
request = request.query(&[("session_check", "1")]);
}
}
if session.id.is_none() || !session.initialized {
request = request.query(&[("database", &self.0.database)]);
}
if self.0.read_only {
if self.0.read_only && !session.strict_read_only {
request = request.query(&[("readonly", "1")]);
}
request
@@ -200,7 +265,7 @@ impl ClickhousePool {
};
let client = self.client()?;
let query_id = uuid::Uuid::new_v4().to_string();
let request = self.request(&client, &query_id, skip.saturating_add(max_rows), *session).body(sql.to_owned());
let request = self.request(&client, &query_id, skip.saturating_add(max_rows), &session).body(sql.to_owned());
let started = Instant::now();
let fetch = async {
let mut response = request.send().await.map_err(http_error)?;
@@ -254,7 +319,7 @@ impl ClickhousePool {
match result {
Some(result) => {
if result.is_ok() {
*session = true;
session.initialized = true;
}
result
}
@@ -307,11 +372,7 @@ impl ClickhousePool {
let auth = matches!(status, StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN)
|| matches!(code, Some("193" | "194" | "195" | "516" | "497"));
let detail = if message.is_empty() { status.canonical_reason().unwrap_or("request failed") } else { &message };
let detail = if detail.contains("SESSION_NOT_FOUND") || detail.contains("Session not found") {
"ClickHouse HTTP session expired; reconnect to restore session settings"
} else {
detail
};
let detail = if code == Some("372") || session_not_found(detail) { SESSION_LOST } else { detail };
self.redact_error(IdeError::new(
if auth { ErrorKind::PermissionDenied } else { ErrorKind::InvalidInput },
format!("ClickHouse HTTP {}: {detail}", status.as_u16()),
@@ -323,9 +384,9 @@ type DecodedResult = (Vec<ResultColumn>, Vec<Vec<Option<String>>>, bool);
/// Decodes a streamed [`FORMAT`] body. Reads past the first `skip` rows unparsed (a later
/// page), then keeps `max_rows` rows; later rows only set `has_more` and are read past
/// unparsed, so a grid limit bounds memory however large the block
/// `result_overflow_mode=break` lets the server send. A line that is not a JSON array
/// starts the exception ClickHouse writes when a query fails mid-stream.
/// unparsed, so a grid limit bounds memory even if a strict read-only server does not allow
/// per-query result limits. A line that is not a JSON array starts the exception ClickHouse
/// writes when a query fails mid-stream.
struct RowReader {
skip: usize,
max_rows: usize,
@@ -433,7 +494,11 @@ impl RowReader {
let rest = std::mem::take(&mut self.pending);
self.line(&rest)?;
if let Some(exception) = self.exception {
return Err(IdeError::invalid(format!("ClickHouse: {}", exception_text(&exception))));
let detail = exception_text(&exception);
return Err(IdeError::invalid(format!(
"ClickHouse: {}",
if session_not_found(detail) { SESSION_LOST } else { detail }
)));
}
let Some(names) = self.names else { return Ok((Vec::new(), Vec::new(), false)) };
let types = self.types.unwrap_or_default();
@@ -445,6 +510,13 @@ impl RowReader {
}
}
/// Whether a server message reports a named HTTP session this node doesn't have.
fn session_not_found(detail: &str) -> bool {
detail.starts_with("Code: 372.")
|| detail.starts_with("Session not found")
|| detail.starts_with("SESSION_NOT_FOUND")
}
/// The server's message in a failed response: rows already streamed and the
/// `__exception__` block markers ClickHouse wraps a mid-stream error in are dropped.
fn exception_text(body: &str) -> &str {
@@ -479,6 +551,20 @@ fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
.map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
}
fn rejects_driver_setting(error: &IdeError) -> bool {
error
.message
.split_once(": ")
.and_then(|(_, detail)| detail.strip_prefix("Code: 164. DB::Exception: Cannot modify '"))
.and_then(|detail| detail.split_once("' setting in readonly mode"))
.is_some_and(|(name, _)| {
matches!(
name,
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
)
})
}
fn reserved_setting(name: &str) -> bool {
let name = name.to_ascii_lowercase();
name.starts_with("output_format_json_")
@@ -575,6 +661,19 @@ mod tests {
DataSource { driver: DbDriver::Clickhouse, host: "127.0.0.1".into(), port: Some(port), ..Default::default() }
}
fn property(name: &str, value: &str) -> DbProperty {
DbProperty { name: name.into(), value: value.into() }
}
fn request_url(request: &str) -> Url {
let target = request.lines().next().unwrap().split_whitespace().nth(1).unwrap();
Url::parse(&format!("http://localhost{target}")).unwrap()
}
fn query_value(url: &Url, key: &str) -> Option<String> {
url.query_pairs().find(|(name, _)| name == key).map(|(_, value)| value.into_owned())
}
fn decode(body: &[u8], max_rows: usize, chunk: usize) -> IdeResult<DecodedResult> {
decode_from(body, 0, max_rows, chunk)
}
@@ -653,6 +752,7 @@ mod tests {
let (port, requests) = server(vec![
("200 OK", "X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n", ONE),
("200 OK", "", ""),
("200 OK", "", ""),
(
"200 OK",
"X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n",
@@ -664,7 +764,7 @@ mod tests {
user: "reader".into(),
read_only: true,
options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
properties: vec![property("max_threads", "2"), property("use_http_session", "true")],
..source(port)
};
let pool = Pool::connect(&source, Some("mock-password"), None).await.unwrap();
@@ -687,7 +787,7 @@ mod tests {
assert_eq!(value(&urls[1], "session_check").as_deref(), Some("1"));
assert_eq!(value(&urls[0], "session_id"), value(&urls[2], "session_id"));
assert_ne!(value(&urls[0], "query_id"), value(&urls[2], "query_id"));
assert_eq!(value(&urls[2], "max_result_rows").as_deref(), Some("2"));
assert_eq!(value(&urls[3], "max_result_rows").as_deref(), Some("2"));
for (request, url) in requests.iter().zip(&urls) {
assert!(request.starts_with("POST /?"));
assert!(request.contains("Basic cmVhZGVyOm1vY2stcGFzc3dvcmQ="));
@@ -695,8 +795,10 @@ mod tests {
assert_eq!(value(url, "readonly").as_deref(), Some("1"));
assert_eq!(value(url, "session_timezone").as_deref(), Some("UTC"));
assert_eq!(value(url, "max_threads").as_deref(), Some("2"));
assert_eq!(value(url, "use_http_session"), None);
}
assert!(requests[0].ends_with("SELECT 1"));
assert!(requests[1].ends_with("USE `analytics`"));
assert!(pool.transaction(&[]).await.is_err());
let cancel = CancellationToken::new();
cancel.cancel();
@@ -706,6 +808,71 @@ mod tests {
assert!(pool.execute("SELECT 1", 1, &CancellationToken::new()).await.is_err());
}
#[tokio::test]
async fn stateless_requests_keep_database_settings_readonly_and_limits() {
let (port, requests) = server(vec![("200 OK", "", ONE); 3]).await;
let source = DataSource {
database: "configured_database".into(),
read_only: true,
options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
..source(port)
};
let pool = Pool::connect(&source, None, None).await.unwrap();
pool.execute("SELECT 2", 2, &CancellationToken::new()).await.unwrap();
pool.execute("SELECT 3", 3, &CancellationToken::new()).await.unwrap();
let requests = requests.await.unwrap();
let mut query_ids = std::collections::HashSet::new();
for (index, request) in requests.iter().enumerate() {
let url = request_url(request);
for name in ["session_id", "session_check", "session_timeout", "use_http_session"] {
assert_eq!(query_value(&url, name), None, "{name} must not be sent in stateless mode");
}
assert_eq!(query_value(&url, "database").as_deref(), Some("analytics"));
assert_eq!(query_value(&url, "session_timezone").as_deref(), Some("UTC"));
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
assert_eq!(query_value(&url, "max_result_rows"), Some((index + 2).to_string()));
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), Some("break"));
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), Some("1"));
assert_eq!(query_value(&url, "default_format").as_deref(), Some(FORMAT));
assert!(query_ids.insert(query_value(&url, "query_id").unwrap()));
assert!(request.ends_with(&format!("SELECT {}", index + 1)));
}
}
#[tokio::test]
async fn default_session_expiry_never_recreates_the_session_or_replays_sql() {
for failure in [
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 372\r\n", "session unavailable"),
("500 Internal Server Error", "", "Code: 372. DB::Exception: Session not found. (SESSION_NOT_FOUND)"),
("200 OK", "", "Code: 372. DB::Exception: Session not found. (SESSION_NOT_FOUND)"),
] {
let (port, requests) = server(vec![("200 OK", "", ONE), failure, ("200 OK", "", ONE)]).await;
let pool = Pool::connect(&source(port), None, None).await.unwrap();
let sql = "INSERT INTO events VALUES (1)";
let error = pool.execute(sql, 0, &CancellationToken::new()).await.unwrap_err();
assert!(error.message.contains("372"));
assert!(error.message.contains("one node or session affinity"));
assert!(error.message.contains("use_http_session=false"));
pool.execute("SELECT 1", 1, &CancellationToken::new()).await.unwrap();
let requests = requests.await.unwrap();
assert_eq!(requests.len(), 3);
assert!(requests[0].ends_with("SELECT 1"));
assert!(requests[1].ends_with(sql));
assert!(requests[2].ends_with("SELECT 1"));
let session_id = query_value(&request_url(&requests[0]), "session_id").unwrap();
for request in &requests[1..] {
let url = request_url(request);
assert_eq!(query_value(&url, "session_id").as_deref(), Some(session_id.as_str()));
assert_eq!(query_value(&url, "session_check").as_deref(), Some("1"));
assert_eq!(query_value(&url, "database"), None);
}
}
}
#[tokio::test]
async fn sequential_queries_reuse_the_http_connection() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
@@ -726,6 +893,144 @@ mod tests {
task.await.unwrap();
}
#[tokio::test]
async fn connects_when_server_forbids_settings_in_readonly_mode() {
let (port, requests) = server(vec![
(
"500 Internal Server Error",
"X-ClickHouse-Exception-Code: 164\r\n",
"Code: 164. DB::Exception: Cannot modify 'output_format_json_quote_denormals' setting in readonly mode. (READONLY)",
),
("200 OK", "", ONE),
("200 OK", "", ""),
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[1]\n[2]\n"),
])
.await;
let source = DataSource {
database: "system".into(),
read_only: true,
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
..source(port)
};
let pool = Pool::connect(&source, None, None).await.unwrap();
let result = pool.execute("SELECT number FROM numbers(2)", 1, &CancellationToken::new()).await.unwrap();
assert_eq!(result.rows, vec![vec![Some("1".into())]]);
assert!(result.has_more);
let requests = requests.await.unwrap();
assert!(requests[0].ends_with("SELECT 1"));
assert!(requests[0].contains("output_format_json_quote_denormals=1"));
assert!(requests[1].ends_with("SELECT getSetting('readonly')"));
assert!(!requests[1].contains("session_check="));
assert_eq!(query_value(&request_url(&requests[1]), "database").as_deref(), Some("system"));
assert!(requests[2].contains("session_check=1"));
let session_id = query_value(&request_url(&requests[1]), "session_id").unwrap();
assert_ne!(query_value(&request_url(&requests[0]), "session_id").as_deref(), Some(session_id.as_str()));
for request in &requests[1..] {
assert_eq!(query_value(&request_url(request), "session_id").as_deref(), Some(session_id.as_str()));
assert!(request.contains("default_format=JSONCompactEachRowWithNamesAndTypes"));
assert!(request.contains("max_threads=2"));
for setting in
["output_format_json_quote_denormals=", "max_result_rows=", "result_overflow_mode=", "readonly="]
{
assert!(!request.contains(setting), "{setting} is not allowed in a strict read-only session");
}
}
}
#[tokio::test]
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
for read_only in [false, true] {
let (port, requests) = server(vec![(
"500 Internal Server Error",
"X-ClickHouse-Exception-Code: 164\r\n",
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
)])
.await;
let source =
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
assert!(error.message.contains("use_http_session=false requires per-request"));
let requests = requests.await.unwrap();
assert_eq!(requests.len(), 1);
assert!(requests[0].ends_with("SELECT 1"));
let url = request_url(&requests[0]);
assert_eq!(query_value(&url, "max_result_rows").as_deref(), Some("2"));
assert_eq!(query_value(&url, "readonly").as_deref(), read_only.then_some("1"));
assert_eq!(query_value(&url, "session_id"), None);
}
}
#[tokio::test]
async fn incompatible_stateless_options_are_rejected_before_connecting() {
for (properties, startup_script, expected) in [
(vec![property("use_http_session", "false")], "SET max_threads = 2", "does not support startup scripts"),
(vec![property("use_http_session", "invalid")], "", "must be true or false"),
(
vec![property("use_http_session", "false"), property("USE_HTTP_SESSION", "true")],
"",
"must be specified only once",
),
(
vec![property("use_http_session", "false"), property("session_id", "custom")],
"",
"manages the session_id",
),
(
vec![property("use_http_session", "false"), property("session_check", "0")],
"",
"manages the session_check",
),
(
vec![property("use_http_session", "false"), property("session_timeout", "60")],
"",
"manages the session_timeout",
),
] {
let source = DataSource {
properties,
options: DbOptions { startup_script: startup_script.into(), ..Default::default() },
..source(1)
};
let error = Pool::connect(&source, None, None).await.err().expect("incompatible options must fail");
assert!(error.message.contains(expected), "{}", error.message);
}
}
#[tokio::test]
async fn readonly_probe_does_not_disable_settings_on_a_writable_session() {
let (port, requests) = server(vec![
(
"500 Internal Server Error",
"X-ClickHouse-Exception-Code: 164\r\n",
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
),
("200 OK", "", "[\"readonly\"]\n[\"UInt64\"]\n[0]\n"),
])
.await;
let source = DataSource { read_only: true, ..source(port) };
let error = Pool::connect(&source, None, None).await.err().expect("writable session must stay rejected");
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
assert!(requests.await.unwrap()[1].ends_with("SELECT getSetting('readonly')"));
}
#[test]
fn readonly_probe_matches_only_the_driver_settings() {
for (code, setting, expected) in [
(164, "max_result_rows", true),
(164, "result_overflow_mode", true),
(164, "readonly", true),
(164, "max_threads", false),
(516, "max_result_rows", false),
] {
let error = IdeError::invalid(format!(
"ClickHouse HTTP 500: Code: {code}. DB::Exception: Cannot modify '{setting}' setting in readonly mode. (READONLY)"
));
assert_eq!(rejects_driver_setting(&error), expected, "{setting}");
}
}
#[tokio::test]
async fn server_errors_keep_details_and_hide_passwords() {
let (port, requests) = server(vec![(
+31
Переглянути файл
@@ -916,6 +916,37 @@ impl DbManager {
self.tunnels.lock().remove(id);
}
/// Creates a database on the server of data source `id` by running `statement` on the data
/// source's own database, after closing the IDE's connections to `template`, the database
/// the server copies (PostgreSQL and SQL Server refuse to copy one that has sessions).
pub async fn create_database(&self, id: &str, template: &str, statement: &str) -> IdeResult<()> {
let id = split_target(id).0;
if self.source(id)?.read_only {
return Err(IdeError::new(ErrorKind::PermissionDenied, "the data source is read-only"));
}
self.disconnect(&format!("{id}:{template}")).await;
self.pool(id).await?.execute(statement, 0, &CancellationToken::new()).await?;
self.remember_statement(id, statement);
Ok(())
}
/// Drops `database` of the server of data source `id` by running `statement` on the data
/// source's own database, after closing the IDE's connections to `database`.
/// Refuses the database the data source connects to and read-only data sources.
pub async fn drop_database(&self, id: &str, database: &str, statement: &str) -> IdeResult<()> {
let id = split_target(id).0;
if self.source(id)?.read_only {
return Err(IdeError::new(ErrorKind::PermissionDenied, "the data source is read-only"));
}
if self.databases(id).await?.current == database {
return Err(IdeError::invalid(format!("the data source connects to {database}; it cannot drop it")));
}
self.disconnect(&format!("{id}:{database}")).await;
self.pool(id).await?.execute(statement, 0, &CancellationToken::new()).await?;
self.remember_statement(id, statement);
Ok(())
}
/// The databases of the server of data source `id` (PostgreSQL), the connected one first.
pub async fn databases(&self, id: &str) -> IdeResult<Databases> {
let id = split_target(id).0;
+38
Переглянути файл
@@ -230,6 +230,44 @@ async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> {
}
/// Runs `job` with the newest installed copy of its tool, the way the dialogs do.
#[tokio::test]
async fn drops_a_database_the_ide_holds_connections_to() -> IdeResult<()> {
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let c = CancellationToken::new();
db.execute("p", "DROP DATABASE IF EXISTS oi_drop_me", 0, &c).await?;
db.execute("p", "CREATE DATABASE oi_drop_me TEMPLATE template0", 0, &c).await?;
// What the tree and a manual-commit console leave open on the database.
db.schemas("p:oi_drop_me").await?;
db.set_manual_commit("p:oi_drop_me", true).await?;
db.execute("p:oi_drop_me", "SELECT 1", 1, &c).await?;
db.drop_database("p", "oi_drop_me", "drop database oi_drop_me").await?;
assert!(!db.is_connected("p:oi_drop_me"));
assert!(!db.databases("p").await?.names.iter().any(|n| n == "oi_drop_me"));
let current = db.databases("p").await?.current;
let refused = db.drop_database("p", &current, &format!("drop database \"{current}\"")).await;
assert!(refused.is_err());
Ok(())
}
#[tokio::test]
async fn creates_a_database_from_a_template_the_ide_holds_connections_to() -> IdeResult<()> {
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let c = CancellationToken::new();
db.execute("p", "DROP DATABASE IF EXISTS oi_from_template", 0, &c).await?;
db.schemas("p:template1").await?;
db.create_database("p", "template1", "create database oi_from_template").await?;
assert!(!db.is_connected("p:template1"));
assert!(db.databases("p").await?.names.iter().any(|n| n == "oi_from_template"));
db.execute("p", "DROP DATABASE oi_from_template", 0, &c).await?;
Ok(())
}
async fn run_tool(db: &DbManager, target: &str, job: ide_db::tools::DbToolJob) -> IdeResult<()> {
let install = ide_db::tools::find_installs(job.tool()).into_iter().next().expect("installed");
let mut lines = Vec::new();
+41
Переглянути файл
@@ -95,3 +95,44 @@ async fn sqlserver_values_paging_transactions_and_cancellation() {
task.await.unwrap();
assert_eq!(pool.rows("SELECT 1", 1).await.unwrap()[0][0].as_deref(), Some("1"));
}
#[tokio::test]
async fn sqlserver_creates_from_a_held_model_and_force_drops_a_held_database() {
let Ok(server) = std::env::var("OPENIDEA_TEST_SQLSERVER") else { return };
let mut parts = server.splitn(4, ':');
let (host, port, user, password) = (
parts.next().unwrap(),
parts.next().unwrap().parse().unwrap(),
parts.next().unwrap(),
parts.next().unwrap_or(""),
);
let source = |database: &str| DataSource {
id: "s".into(),
name: "sqlserver".into(),
driver: DbDriver::SqlServer,
host: host.into(),
port: Some(port),
user: user.into(),
database: database.into(),
ssl: DbSslMode::Disable,
..Default::default()
};
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().to_path_buf();
let ssh = std::sync::Arc::new(ide_ssh::SshManager::new(root.join("ssh-passwords.json")));
let db = ide_db::DbManager::new(root.clone(), root.join("passwords.json"), root.join("history.json"), ssh);
db.save_sources(vec![source("master")]).await.unwrap();
db.set_password("s", Some(password.into()), false).await.unwrap();
let name = format!("oi_force_drop_{}", std::process::id());
// The tree's connection to `model` would keep SQL Server from copying it.
db.schemas("s:model").await.unwrap();
db.create_database("s", "model", &format!("create database {name};")).await.unwrap();
assert!(!db.is_connected("s:model"));
let other = Pool::connect(&source(&name), Some(password), None).await.unwrap();
let held = Held::acquire(&other).await.unwrap();
let force = format!("alter database {name} set single_user with rollback immediate;\ndrop database {name};");
db.drop_database("s", &name, &force).await.unwrap();
assert!(!db.databases("s").await.unwrap().names.contains(&name));
drop(held);
}
+198 -11
Переглянути файл
@@ -2,9 +2,9 @@
use crate::Host;
use ide_core::event::NotifyLevel;
use ide_core::settings::{ExternalFormatter, LanguagesSettings};
use ide_core::{DocId, IdeError, IdeEvent, IdeResult, Pos, Range, TextEdit};
use ide_language::LanguageConfig;
use ide_core::settings::{ExternalFormatter, LanguagesSettings, Settings};
use ide_core::{ChangeSet, DocId, IdeError, IdeEvent, IdeResult, LanguageId, Pos, Range, TextEdit};
use ide_language::{LanguageConfig, PhpAlignment, Syntax};
use ide_lsp::types::FormatOptions;
use ide_tools::{Tools, formatter};
use std::path::Path;
@@ -129,12 +129,101 @@ pub async fn format(
let project = host.project(window)?;
let snap = project.documents.snapshot(doc)?;
let settings = project.settings.effective();
let alignment = php_alignment(&settings, &snap.language);
let original = alignment.any().then(|| (snap.language.clone(), snap.text.clone()));
let Some(edits) = provider_edits(host, window, &project, snap, settings, range, options).await? else {
return Ok(Vec::new());
};
let Some((language, text)) = original else {
return Ok(edits);
};
let syntax = host.syntax();
tokio::task::spawn_blocking(move || align_formatted(&syntax, &language, &text, edits, range, alignment))
.await
.map_err(|e| IdeError::internal(e.to_string()))?
}
/// PHP Code Style › Align key-value pairs / Align consecutive assignments (off by default, as in PhpStorm).
fn php_alignment(settings: &Settings, language: &LanguageId) -> PhpAlignment {
let style = settings.editor.code_style.languages.get(language.as_str());
PhpAlignment {
key_value_pairs: style.and_then(|s| s.align_key_value_pairs).unwrap_or(false),
assignments: style.and_then(|s| s.align_consecutive_assignments).unwrap_or(false),
}
}
/// The formatter's `edits` to `text` followed by the alignment, as one set of edits to `text`.
/// With a `range`, only its lines (where the formatter left them) are aligned.
fn align_formatted(
syntax: &Syntax,
language: &LanguageId,
text: &str,
edits: Vec<TextEdit>,
range: Option<Range>,
alignment: PhpAlignment,
) -> IdeResult<Vec<TextEdit>> {
let mut formatted = ide_text::Document::new(text);
// Edits the editor has to sort out itself (overlapping ones) are passed on unaligned.
let Ok((changes, _)) = formatted.apply_edits(&edits) else {
return Ok(edits);
};
let lines = range.map(|range| {
let original = ide_text::Document::new(text);
let start = formatted.offset_to_pos(map_offset(&changes, original.pos_to_offset(range.start), false));
let end = formatted.offset_to_pos(map_offset(&changes, original.pos_to_offset(range.end), true));
let last = if end.col == 0 && end.line > start.line { end.line - 1 } else { end.line };
(start.line as usize, last as usize)
});
let Some(aligned) = syntax.align_php(language, &formatted.text(), lines, alignment) else {
return Ok(edits);
};
let original = ide_text::Document::new(text);
Ok(original
.diff(&aligned)
.changes
.into_iter()
.map(|c| TextEdit {
range: Range::new(original.offset_to_pos(c.from), original.offset_to_pos(c.to)),
new_text: c.insert,
})
.collect())
}
/// Where UTF-16 `offset` of the text before `changes` ends up after them; inside a replaced
/// part, at its start or (`end`) its end.
fn map_offset(changes: &ChangeSet, offset: u32, end: bool) -> u32 {
let mut shift: i64 = 0;
for c in &changes.changes {
let inserted = c.insert.encode_utf16().count() as i64;
if c.to < offset || (c.to == offset && (c.from < c.to || end)) {
shift += inserted - i64::from(c.to - c.from);
} else if c.from < offset {
return (i64::from(c.from) + shift + if end { inserted } else { 0 }) as u32;
} else {
break;
}
}
(i64::from(offset) + shift) as u32
}
/// The edits of the formatter that handles the document; `None` when it doesn't run
/// (formatting on save is off for it).
async fn provider_edits(
host: &Host,
window: &str,
project: &crate::Project,
snap: ide_workspace::documents::DocumentInfo,
settings: Settings,
range: Option<Range>,
options: FormatOptions,
) -> IdeResult<Option<Vec<TextEdit>>> {
let doc = snap.id;
let language = project.languages.get(&snap.language);
if options.tool.is_none()
&& let Some(id) = settings.languages.plugin_formatters.get(snap.language.as_str()).filter(|s| !s.is_empty())
{
if options.on_save && !settings.editor.format_on_save {
return Ok(Vec::new());
return Ok(None);
}
if snap.read_only {
return Err(IdeError::invalid("The file is read-only"));
@@ -160,7 +249,8 @@ pub async fn format(
)
})
.await
.map_err(|e| IdeError::internal(e.to_string()))?;
.map_err(|e| IdeError::internal(e.to_string()))?
.map(Some);
}
// A committed PHP-CS-Fixer configuration takes over Reformat Code for `.php` files.
if options.tool.is_none()
@@ -168,7 +258,7 @@ pub async fn format(
&& let Some(fixer) = formatter::php_cs_fixer(&snap.path)
{
if options.on_save && !settings.editor.format_on_save {
return Ok(Vec::new());
return Ok(None);
}
host.require_trust(window)?;
if snap.read_only {
@@ -188,7 +278,7 @@ pub async fn format(
body: Some("PHP-CS-Fixer does not support selection formatting; formatted the whole file".into()),
});
}
return Ok(edits);
return Ok(Some(edits));
}
let mut selected = external_tool(options.tool, language.as_ref(), &snap.path, &settings.languages)?;
if let Some(tool) = selected
@@ -200,13 +290,13 @@ pub async fn format(
}
let Some(selected) = selected else {
if options.on_save && !settings.editor.format_on_save {
return Ok(Vec::new());
return Ok(None);
}
return project.lsp.format(doc, range, options).await;
return project.lsp.format(doc, range, options).await.map(Some);
};
let tool_settings = settings.languages.formatter(selected);
if options.on_save && !tool_settings.run_on_save {
return Ok(Vec::new());
return Ok(None);
}
host.require_trust(window)?;
if snap.read_only {
@@ -262,7 +352,7 @@ pub async fn format(
)),
});
}
edits.map_err(|e| e.with_tool(tool))
edits.map(Some).map_err(|e| e.with_tool(tool))
}
#[cfg(test)]
@@ -413,6 +503,103 @@ mod tests {
);
}
fn after(text: &str, edits: &[TextEdit]) -> String {
let mut doc = ide_text::Document::new(text);
doc.apply_edits(edits).unwrap();
doc.text()
}
fn whole_file(text: &str, formatted: &str) -> Vec<TextEdit> {
let doc = ide_text::Document::new(text);
doc.diff(formatted)
.changes
.into_iter()
.map(|c| TextEdit {
range: Range::new(doc.offset_to_pos(c.from), doc.offset_to_pos(c.to)),
new_text: c.insert,
})
.collect()
}
const ALIGN: PhpAlignment = PhpAlignment { key_value_pairs: true, assignments: true };
#[test]
fn php_alignment_is_off_unless_the_php_code_style_turns_it_on() {
let php = LanguageId::new("php");
let mut settings = Settings::default();
assert_eq!(php_alignment(&settings, &php), PhpAlignment::default());
let style =
ide_core::editor_settings::LanguageCodeStyle { align_key_value_pairs: Some(true), ..Default::default() };
settings.editor.code_style.languages.insert("php".into(), style);
assert_eq!(php_alignment(&settings, &php), PhpAlignment { key_value_pairs: true, assignments: false });
assert_eq!(php_alignment(&settings, &LanguageId::new("javascript")), PhpAlignment::default());
}
#[test]
fn alignment_follows_the_formatter_edits_even_when_there_are_none() {
let syntax = Syntax::new();
let php = LanguageId::new("php");
let text = "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
let edits = align_formatted(&syntax, &php, text, Vec::new(), None, ALIGN).unwrap();
assert_eq!(after(text, &edits), "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
// The language server re-indents the array: the alignment applies to its result.
let text = "<?php\n$a = [\n'a' => 1,\n'bbb' => 2,\n];\n";
let formatted = "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
let edits = align_formatted(&syntax, &php, text, whole_file(text, formatted), None, ALIGN).unwrap();
assert_eq!(after(text, &edits), "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
let unchanged = whole_file(text, formatted);
let off = align_formatted(&syntax, &php, text, unchanged.clone(), None, PhpAlignment::default()).unwrap();
assert_eq!(off, unchanged);
let overlapping = vec![
TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 4)), new_text: "x".into() },
TextEdit { range: Range::new(Pos::new(1, 2), Pos::new(1, 6)), new_text: "y".into() },
];
let passed = align_formatted(&syntax, &php, text, overlapping.clone(), None, ALIGN).unwrap();
assert_eq!(passed, overlapping);
}
#[test]
fn a_selection_aligns_only_its_lines_whatever_the_formatter_changed() {
let syntax = Syntax::new();
let php = LanguageId::new("php");
let text = "<?php\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
// PHP-CS-Fixer formats the whole file (here: adds a line at the top) whatever the selection.
let formatted = format!("<?php\n\ndeclare(strict_types=1);\n{}", &text["<?php\n".len()..]);
let edits = whole_file(text, &formatted);
// Lines 3..=6 select the array, up to the start of the line after it.
let range = Range::new(Pos::new(3, 0), Pos::new(7, 0));
let aligned = align_formatted(&syntax, &php, text, edits, Some(range), ALIGN).unwrap();
assert_eq!(aligned.len(), 2, "one edit per changed region: {aligned:?}");
assert_eq!(
after(text, &aligned),
"<?php\n\ndeclare(strict_types=1);\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n"
);
let range = Range::new(Pos::new(1, 0), Pos::new(2, 9));
let aligned = align_formatted(&syntax, &php, text, Vec::new(), Some(range), ALIGN).unwrap();
assert_eq!(after(text, &aligned), "<?php\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
}
#[test]
fn offsets_map_through_changes() {
let changes = ChangeSet {
changes: vec![
ide_core::TextChange { from: 2, to: 2, insert: "ab".into() },
ide_core::TextChange { from: 5, to: 8, insert: "x".into() },
],
};
assert_eq!(map_offset(&changes, 0, false), 0);
assert_eq!(map_offset(&changes, 2, false), 2);
assert_eq!(map_offset(&changes, 2, true), 4);
assert_eq!(map_offset(&changes, 4, false), 6);
assert_eq!(map_offset(&changes, 6, false), 7);
assert_eq!(map_offset(&changes, 6, true), 8);
assert_eq!(map_offset(&changes, 8, false), 8);
assert_eq!(map_offset(&changes, 10, false), 10);
}
#[test]
fn ruff_ranges_are_one_based_unicode_columns() {
let text = ide_text::Document::new("😀x = 1\ny = 2\n");
+10
Переглянути файл
@@ -253,6 +253,16 @@ impl Host {
self.project(window)?.require_trust()
}
/// [`Self::require_trust`] for IDE-wide toolchain work (SDK detection, tool installs) that
/// also runs from a window without a project, such as Settings opened from the Welcome
/// screen: there is no project there to trust.
pub fn require_trust_if_project(&self, window: &str) -> IdeResult<()> {
match self.project(window) {
Ok(project) => project.require_trust(),
Err(_) => Ok(()),
}
}
/// The window that owns what `window` starts.
pub fn owner_window<'a>(&self, window: &'a str) -> &'a str {
(self.owner)(window)
+216
Переглянути файл
@@ -356,6 +356,13 @@ async fn run_to_end(call: &Call, config: RunConfig, errors: &mut BuildErrors) ->
t.drain(..cut);
}
});
let config = match resolve_jvm_application(call, config, errors).await? {
Ok(config) => config,
Err(reason) => {
errors.process_outputs.push(reason);
return Ok(false);
}
};
let info = crate::ops::run::run_start(&call.host(), call.window(), config, emit, None).await?;
let exit = wait_exit(call, info.id, None).await?.flatten();
if exit == Some(0) {
@@ -367,6 +374,177 @@ async fn run_to_end(call: &Call, config: RunConfig, errors: &mut BuildErrors) ->
Ok(false)
}
/// Run configuration kinds launched as a JVM main class (`JVM_APPLICATION_KINDS` in the UI).
const JVM_APPLICATION_KINDS: [&str; 2] = ["application", "spring-boot"];
const CLASSPATH: &str = "${classpath}";
const TEST_CLASSPATH: &str = "${testClasspath}";
/// `java` options whose value is the next argument (`parseJavaArgs` in the UI).
const JAVA_OPTIONS_WITH_VALUE: [&str; 13] = [
"-cp",
"-classpath",
"--class-path",
"-p",
"--module-path",
"--upgrade-module-path",
"--add-modules",
"--add-opens",
"--add-exports",
"--add-reads",
"--patch-module",
"--limit-modules",
"--enable-native-access",
];
/// The main class of `java` arguments and which classpath placeholder they use (`Some(true)`:
/// `${testClasspath}`; `None`: an explicit classpath or none).
fn java_main_class(args: &[String]) -> (Option<&str>, Option<bool>) {
let mut test = None;
let mut i = 0;
while i < args.len() {
let a = args[i].as_str();
if a == "-jar" {
return (None, test);
}
if matches!(a, "-cp" | "-classpath" | "--class-path") {
match args.get(i + 1).map(String::as_str) {
Some(CLASSPATH) => test = Some(false),
Some(TEST_CLASSPATH) => test = Some(true),
_ => {}
}
i += 2;
continue;
}
if JAVA_OPTIONS_WITH_VALUE.contains(&a) {
i += 2;
continue;
}
if !a.starts_with('-') {
return (Some(a), test);
}
i += 1;
}
(None, test)
}
/// `args` with the classpath placeholders replaced and the module path added (`resolveJavaCommand`).
fn resolved_java_args(args: &[String], info: &ide_lsp::jdtls::JavaLaunchInfo) -> Vec<String> {
let cp = info.class_paths.join(&info.path_list_separator);
let mut out = Vec::with_capacity(args.len() + 2);
if !info.module_paths.is_empty() && !args.iter().any(|a| a == "-p" || a == "--module-path") {
out.push("--module-path".to_owned());
out.push(info.module_paths.join(&info.path_list_separator));
}
out.extend(args.iter().map(|a| if a == CLASSPATH || a == TEST_CLASSPATH { cp.clone() } else { a.clone() }));
out
}
/// The module (relative to the project root) of a JVM source file: the part before
/// `src/<set>/<language>/` (`jvmModuleDir` without a build model).
fn jvm_module_of(rel: &str) -> Option<String> {
let rel = rel.replace('\\', "/");
let parts: Vec<&str> = rel.split('/').collect();
(0..parts.len().saturating_sub(3)).find_map(|i| {
(parts[i] == "src" && matches!(parts[i + 2], "java" | "kotlin" | "scala" | "groovy"))
.then(|| parts[..i].join("/"))
})
}
/// The module of a configuration saved without one, found from its main class's source
/// (`findJavaModule`): `None` unless exactly one module declares it.
async fn find_java_module(call: &Call, main: &str) -> IdeResult<Option<String>> {
let outer = main.split('$').next().unwrap_or(main);
let (pkg, simple) = outer.rsplit_once('.').unwrap_or(("", outer));
let mut names = vec![format!("{simple}.java"), format!("{simple}.kt")];
if let Some(stem) = simple.strip_suffix("Kt") {
names.push(format!("{stem}.kt"));
}
let mut modules = std::collections::BTreeSet::new();
for name in names {
for path in crate::ops::nav::find_files_named(&call.host(), call.window(), name).await? {
let path = std::path::PathBuf::from(path);
let Ok(text) = std::fs::read_to_string(&path) else { continue };
let declared = text
.lines()
.map(str::trim)
.find_map(|l| l.strip_prefix("package "))
.map(|p| p.trim_end_matches(';').trim())
.unwrap_or("");
if declared != pkg {
continue;
}
let rel = path.strip_prefix(call.root()).unwrap_or(&path).to_string_lossy().into_owned();
modules.insert(jvm_module_of(&rel).unwrap_or_default());
}
}
Ok((modules.len() == 1).then(|| modules.into_iter().next().unwrap_or_default()))
}
/// A JVM application configuration ready to start, as the Run tool window launches it:
/// built per its before-launch build policy, with `${classpath}` / `${testClasspath}`, the
/// module path and the module's `java` resolved through jdtls. `Err` says why it cannot start
/// (compile errors are added to `errors`). Other configurations are returned as they are.
async fn resolve_jvm_application(
call: &Call,
config: RunConfig,
errors: &mut BuildErrors,
) -> IdeResult<Result<RunConfig, String>> {
if !JVM_APPLICATION_KINDS.contains(&config.kind.as_str()) {
return Ok(Ok(config));
}
let (main, test) = java_main_class(&config.args);
let Some(main) = main.map(str::to_owned) else {
return Ok(Err(format!("No main class in '{}'", config.name)));
};
let module = match config.extras.module.clone() {
Some(module) => module,
None => match find_java_module(call, &main).await? {
Some(module) => module,
None => return Ok(Err(format!("Cannot determine the module for main class '{main}'"))),
},
};
let policy = config.extras.build_policy.unwrap_or_default();
let cancel = ide_core::CancellationToken::new();
let host = call.host();
let info = crate::ops::java::resolve_launch(
&host,
call.window(),
std::path::PathBuf::from(&module),
test == Some(true),
policy,
&cancel,
)
.await?;
use ide_lsp::jdtls::JavaBuildStatus;
if matches!(info.build, Some(JavaBuildStatus::Failed | JavaBuildStatus::WithErrors))
&& policy != ide_run::BuildPolicy::MakeAndContinueOnErrors
{
for e in &info.errors {
errors.errors.push(format!(
"{}:{}: {}",
std::path::PathBuf::from(e.path.clone()).display(),
e.line,
e.message
));
}
let reason = if info.build == Some(JavaBuildStatus::Failed) {
format!("Build failed; '{}' was not started.", config.name)
} else {
format!("Build has compile errors; '{}' was not started.", config.name)
};
return Ok(Err(reason));
}
if test.is_some() && info.class_paths.is_empty() {
return Ok(Err("The classpath is empty: is the module imported by the Java language server?".to_owned()));
}
let args = resolved_java_args(&config.args, &info);
let command = match (&info.java_exec, config.command.as_str()) {
(Some(exec), "java") => exec.clone(),
_ => config.command.clone(),
};
Ok(Ok(RunConfig { command, args, ..config }))
}
/// The configuration's before-launch tasks, as the Run tool window runs them; returns why
/// the launch is aborted, if it is. Tool windows are not activated.
async fn before_launch(
@@ -608,6 +786,10 @@ one by one",
if let Some(reason) = before_launch(&call, &config, &configs, &mut Vec::new(), &mut errors).await? {
return Err(execution_failed(&[errors.text(), Some(reason)]));
}
let config = match resolve_jvm_application(&call, config, &mut errors).await? {
Ok(config) => config,
Err(reason) => return Err(execution_failed(&[errors.text(), Some(reason)])),
};
let collector = Arc::new(Mutex::new(OutputCollector::create(&config.name)?));
let output_path = collector.lock().path.clone();
let sink = collector.clone();
@@ -684,6 +866,40 @@ provided, values are merged over existing env.",
mod tests {
use super::*;
fn strings(args: &[&str]) -> Vec<String> {
args.iter().map(|a| (*a).to_owned()).collect()
}
#[test]
fn java_arguments_name_the_main_class_and_classpath_placeholder() {
let run = strings(&["-Xmx1g", "-cp", CLASSPATH, "--add-opens", "a/b=ALL-UNNAMED", "com.example.App", "x"]);
assert_eq!(java_main_class(&run), (Some("com.example.App"), Some(false)));
assert_eq!(java_main_class(&strings(&["-classpath", TEST_CLASSPATH, "T"])), (Some("T"), Some(true)));
assert_eq!(java_main_class(&strings(&["-cp", "lib/*", "Main"])), (Some("Main"), None));
assert_eq!(java_main_class(&strings(&["-jar", "app.jar"])), (None, None));
}
#[test]
fn resolved_java_arguments_replace_the_placeholder_and_add_the_module_path() {
let info = ide_lsp::jdtls::JavaLaunchInfo {
class_paths: vec!["/p/target/classes".into(), "/m2/a.jar".into()],
module_paths: vec!["/m2/mod.jar".into()],
path_list_separator: ":".into(),
..Default::default()
};
assert_eq!(
resolved_java_args(&strings(&["-cp", CLASSPATH, "App"]), &info),
strings(&["--module-path", "/m2/mod.jar", "-cp", "/p/target/classes:/m2/a.jar", "App"])
);
}
#[test]
fn a_source_file_belongs_to_the_module_before_its_source_set() {
assert_eq!(jvm_module_of("repro-dto/src/main/java/com/example/App.java").as_deref(), Some("repro-dto"));
assert_eq!(jvm_module_of("src/test/kotlin/AppTest.kt").as_deref(), Some(""));
assert_eq!(jvm_module_of("scripts/App.java"), None);
}
fn config() -> RunConfig {
RunConfig {
id: "user:x".into(),
+1 -1
Переглянути файл
@@ -236,7 +236,7 @@ impl Tool {
destructive: false,
output_schema: None,
input_schema: json!({ "type": "object", "properties": {
"projectPath": { "type": "string", "description": "Any directory inside an open project. Optional when only one project is open." }
"projectPath": { "type": "string", "description": "Any directory inside an open project. Defaults to the connection's project (`?project=`) or the only open one." }
}, "required": [] }),
},
handler: Arc::new(move |call| Box::pin(handler(call))),
+22 -5
Переглянути файл
@@ -369,10 +369,21 @@ pub async fn agent_delete(host: &Host, window: &str, task: String, remove_worktr
host.project(window)?.agents.delete(&task, remove_worktree).await
}
/// The task's changed files as `view` compares them (without: since it started).
#[command(trust = trusted)]
pub async fn agent_changes(host: &Host, window: &str, task: String) -> IdeResult<Vec<AgentChange>> {
pub async fn agent_changes(
host: &Host,
window: &str,
task: String,
view: Option<AgentChangesView>,
) -> IdeResult<Vec<AgentChange>> {
host.require_trust(window)?;
host.project(window)?.agents.changes(&task).await
let agents = &host.project(window)?.agents;
match view.unwrap_or_default() {
AgentChangesView::SinceStart => agents.changes(&task).await,
AgentChangesView::Group => Ok(agents.grouped_changes(&task).await?.uncommitted),
AgentChangesView::LastTurn => agents.turn_changes(&task).await,
}
}
/// The task's uncommitted changes and the commits made since it started.
@@ -382,11 +393,17 @@ pub async fn agent_grouped_changes(host: &Host, window: &str, task: String) -> I
host.project(window)?.agents.grouped_changes(&task).await
}
/// Content of `path` when the task started (left side of its diff).
/// Content of `path` as `view` compares it (without: when the task started), the left side of its diff.
#[command(trust = trusted)]
pub async fn agent_base_text(host: &Host, window: &str, task: String, path: IpcPath) -> IdeResult<Option<String>> {
pub async fn agent_base_text(
host: &Host,
window: &str,
task: String,
path: IpcPath,
view: Option<AgentChangesView>,
) -> IdeResult<Option<String>> {
host.require_trust(window)?;
host.project(window)?.agents.base_text(&task, path.into_path_buf()).await
host.project(window)?.agents.base_text(&task, path.into_path_buf(), view.unwrap_or_default()).await
}
/// Rollback: the task's changed files among `paths` (all without) back as `view` compares them.
+28
Переглянути файл
@@ -139,6 +139,32 @@ pub async fn db_disconnect(host: &Host, window: &str, id: String) -> IdeResult<(
Ok(())
}
#[command(trust = trusted)]
pub async fn db_create_database(
host: &Host,
window: &str,
id: String,
template: String,
statement: String,
) -> IdeResult<()> {
// Creates a database on the server of data source `id` with `statement`, copied from `template` (New › Database).
let db = host.project(window)?.db.clone();
db.create_database(&id, &template, &statement).await
}
#[command(trust = trusted)]
pub async fn db_drop_database(
host: &Host,
window: &str,
id: String,
database: String,
statement: String,
) -> IdeResult<()> {
// Drops `database` of the server of data source `id` with `statement` (Drop… on a database node).
let db = host.project(window)?.db.clone();
db.drop_database(&id, &database, &statement).await
}
#[command(trust = trusted)]
pub async fn db_databases(host: &Host, window: &str, id: String) -> IdeResult<Databases> {
// Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`.
@@ -478,10 +504,12 @@ ide_command::domain!(
db_connected,
db_console_path,
db_consoles,
db_create_database,
db_database_catalog,
db_databases,
db_ddl,
db_disconnect,
db_drop_database,
db_execute,
db_explain,
db_finish_transaction,
+13
Переглянути файл
@@ -70,6 +70,18 @@ pub async fn doc_save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
}
/// An automatic save: `false` (nothing written) when the file changed on disk after the
/// buffer was edited, which only an explicit save overwrites.
#[command(trust = always)]
pub async fn doc_autosave(host: &Host, window: &str, doc: DocId) -> IdeResult<bool> {
let project = host.project(window)?;
let saved = host.blocking(move || project.documents.autosave(doc)).await?;
if saved {
host.debugger.refresh_source_mirrors(host.owner_window(window)).await?;
}
Ok(saved)
}
#[command(trust = always)]
pub async fn doc_save_all(host: &Host, window: &str) -> IdeResult<()> {
let project = host.project(window)?;
@@ -109,6 +121,7 @@ ide_command::domain!(
doc_open,
doc_open_untitled,
doc_save,
doc_autosave,
doc_save_all,
doc_save_as,
doc_snapshot,
+5
Переглянути файл
@@ -311,6 +311,11 @@ async fn shutdown_does_not_wait_forever_for_a_stuck_capture() {
shutdown_within(&f.host, std::time::Duration::from_millis(200)).await;
assert!(started.elapsed() < std::time::Duration::from_secs(5));
assert!(cancel.is_cancelled());
// The cleanup is only waited for briefly and finishes in the background on a busy machine.
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
while stuck_dir.exists() && std::time::Instant::now() < deadline {
tokio::time::sleep(std::time::Duration::from_millis(20)).await;
}
assert!(!stuck_dir.exists(), "its directory is removed once the wait is over");
}
+1 -1
Переглянути файл
@@ -34,7 +34,7 @@ pub async fn java_resolve_launch(
result
}
async fn resolve_launch(
pub(crate) async fn resolve_launch(
host: &Host,
window: &str,
module: PathBuf,
+15 -3
Переглянути файл
@@ -359,10 +359,22 @@ pub async fn lsp_goto(host: &Host, window: &str, doc: DocId, pos: Pos, kind: Got
if kind != GotoKind::Definition {
return result;
}
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::Definition) else { return result };
// A Maven placeholder (`@profileActive@` in `application.yml` or `.properties`) navigates to its pom.
let maven = super::maven_placeholder::definition(host, window, doc, pos).await;
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::Definition) else {
return match maven {
None => result,
Some(found) => {
let in_string = in_string_literal(host, window, doc, pos).await;
definition_targets(result, vec![found], in_string)
}
};
};
let found = plugin_call(move || plugins.provide_definition(&d, pos)).await.unwrap_or_default();
let found: Vec<Location> =
found.into_iter().map(|l| Location { path: l.path.into(), range: l.range, uri: None }).collect();
let found: Vec<Location> = maven
.into_iter()
.chain(found.into_iter().map(|l| Location { path: l.path.into(), range: l.range, uri: None }))
.collect();
let in_string = !found.is_empty() && in_string_literal(host, window, doc, pos).await;
definition_targets(result, found, in_string)
}
+154
Переглянути файл
@@ -0,0 +1,154 @@
//! ⌘B on a Maven resource-filtering placeholder: `@property@` in a YAML or properties
//! resource (Spring's `application.yml` / `application.properties`) jumps to the `<properties>` entry that defines it,
//! in the nearest `pom.xml` above the file, up through the project root. Parent
//! poms the nearest pom declares itself are followed from there; a parent outside
//! that walk that no pom declares is not.
use super::doc::blocking;
use crate::Host;
use ide_build::maven;
use ide_core::{DocId, Location, Pos};
use std::path::Path;
/// The definition location of the placeholder under `pos` in `doc`, when `doc` is a
/// YAML or properties file holding a `@token@` there and a pom above it defines that property.
pub(crate) async fn definition(host: &Host, window: &str, doc: DocId, pos: Pos) -> Option<Location> {
let project = host.project(window).ok()?;
blocking(move || {
let snap = project.documents.text_snapshot(doc)?;
if snap.large || !matches!(snap.language.as_str(), "yaml" | "properties") {
return Ok(None);
}
let path = project.documents.identity(doc)?.0;
let Some((name, _token_at)) = placeholder_at(&snap.text, pos) else { return Ok(None) };
Ok(pom_defining(&project.root, &path, &name))
})
.await
.ok()
.flatten()
}
/// The `@token@` enclosing `pos` on its line, with the token's range (UTF-16 columns).
fn placeholder_at(text: &str, pos: Pos) -> Option<(String, ide_core::Range)> {
let line = text.split_inclusive('\n').nth(pos.line as usize)?;
let line = line.trim_end_matches(['\n', '\r']);
let cursor = utf16_to_byte(line, pos.col)?;
let mut opener: Option<usize> = None;
for (i, b) in line.as_bytes().iter().enumerate() {
if *b != b'@' {
continue;
}
if let Some(start) = opener.replace(i) {
let token = &line[start + 1..i];
let valid =
!token.is_empty() && token.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_'));
if valid && start <= cursor && cursor <= i {
let col = |byte: usize| line[..byte].encode_utf16().count() as u32;
return Some((
token.to_owned(),
ide_core::Range::new(Pos::new(pos.line, col(start)), Pos::new(pos.line, col(i + 1))),
));
}
opener = None;
}
}
None
}
/// The nearest `pom.xml` above `from` (up to and including `root`) defining `name`.
fn pom_defining(root: &Path, from: &Path, name: &str) -> Option<Location> {
let mut dir = from.parent()?.to_path_buf();
loop {
let pom = dir.join("pom.xml");
if pom.is_file()
&& let Some(found) = maven::property_declaration(&pom, name, maven::default_local_repo())
{
return Some(Location::file(found.path, found.range));
}
if dir == root || !dir.starts_with(root) {
return None;
}
dir = dir.parent()?.to_path_buf();
}
}
/// UTF-16 column → byte offset within one line.
fn utf16_to_byte(line: &str, col: u32) -> Option<usize> {
let col = col as usize;
let mut units = 0usize;
for (byte, c) in line.char_indices() {
if units == col {
return Some(byte);
}
units += c.len_utf16();
if units > col {
return None;
}
}
(units == col).then_some(line.len())
}
#[cfg(test)]
mod tests {
use super::*;
use ide_core::Pos;
fn at(line: u32, col: u32) -> Pos {
Pos::new(line, col)
}
#[test]
fn finds_the_placeholder_under_the_cursor_and_its_range() {
let text = "spring:\n profiles:\n active: @profileActive@\n";
let (name, range) = placeholder_at(text, at(2, 20)).unwrap();
assert_eq!(name, "profileActive");
assert_eq!(range.start, at(2, 12));
assert_eq!(range.end, at(2, 27));
// The `@`s themselves and inside the token navigate; just past the token does not.
for col in [12u32, 13, 26] {
assert_eq!(placeholder_at(text, at(2, col)).unwrap().0, "profileActive");
}
// A second pair on the line and unrelated cursors stay unresolved.
let multi = "a: @one@ @two@\n";
assert_eq!(placeholder_at(multi, at(0, 4)).unwrap().0, "one");
assert_eq!(placeholder_at(multi, at(0, 10)).unwrap().0, "two");
assert!(placeholder_at(multi, at(0, 8)).is_none(), "between the pairs");
assert!(placeholder_at(multi, at(0, 9)).is_some(), "the opening @ of the next pair");
assert!(placeholder_at(multi, at(0, 14)).is_none(), "just past the last pair");
assert!(placeholder_at("value: plain\n", at(0, 7)).is_none());
}
#[test]
fn the_nearest_pom_wins_and_the_walk_stops_at_the_project_root() {
let tmp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(tmp.path()).unwrap();
let root = base.join("project");
let deep = root.join("core/src/main/resources");
std::fs::create_dir_all(&deep).unwrap();
std::fs::write(
root.join("pom.xml"),
"<project>\n <properties>\n <parentName>parent</parentName>\n </properties>\n</project>\n",
)
.unwrap();
std::fs::create_dir_all(root.join("core")).unwrap();
std::fs::write(
root.join("core/pom.xml"),
"<project>\n <properties>\n <name>module</name>\n </properties>\n</project>\n",
)
.unwrap();
let from = deep.join("application.yml");
// The module pom defines `name` first: its file wins, pointing at its `<name>` entry.
let found = pom_defining(&root, &from, "name").unwrap();
assert_eq!(found.path, root.join("core/pom.xml"));
assert_eq!(found.range.start.line, 2);
// A property only the parent defines resolves there; unknown ones resolve nowhere.
let parent = pom_defining(&root, &from, "parentName").unwrap();
assert_eq!(parent.path, root.join("pom.xml"));
assert_eq!(parent.range.start.line, 2);
assert!(pom_defining(&root, &from, "missing").is_none());
// A file outside the project root has no pom walk.
let outside = tmp.path().join("elsewhere/application.yml");
std::fs::create_dir_all(tmp.path().join("elsewhere")).unwrap();
assert!(pom_defining(&root, &outside, "name").is_none());
}
}
+1
Переглянути файл
@@ -21,6 +21,7 @@ pub mod history;
pub mod java;
pub mod jvm_icons;
pub mod lsp;
pub mod maven_placeholder;
pub mod nav;
pub mod notebook;
pub mod project;
+86 -12
Переглянути файл
@@ -108,27 +108,53 @@ fn detected_and_saved(
}
/// 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.
/// builds) that detection did not reach: deeper than its folder search, or inside the folder of
/// a build it found without being one of that build's projects (a separate build nested there).
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 found = |kind: &str| -> Vec<std::path::PathBuf> {
let mut dirs: Vec<_> = detected
.iter()
.filter(|c| c.kind == kind)
.map(|c| ide_core::project_roots::resolve(root, c.cwd.as_deref().unwrap_or(Path::new(""))))
.collect();
dirs.dedup();
dirs
};
let canonical = |dir: &Path| dunce::canonicalize(dir).unwrap_or_else(|_| dir.to_path_buf());
let profiles = settings.languages.java.maven.profiles(&[]);
let maven_builds = found("maven");
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()
let maven = poms.map(|dir| ide_core::project_roots::resolve(root, &dir)).filter(|dir| {
let dir_canon = canonical(dir);
!maven_builds.iter().any(|build| {
dir.starts_with(build) && ide_build::maven::reactor_member_dirs(build, &profiles).contains(&dir_canon)
})
});
let models = gradle.unwrap_or_default();
let gradle_builds = found("gradle");
let gradle =
models.iter().map(|build| ide_core::project_roots::resolve(root, &root.join(&build.dir))).filter(|dir| {
!gradle_builds.iter().any(|build| {
dir == build
|| (dir.starts_with(build)
&& models.iter().filter(|m| root.join(&m.dir) == *build).any(|m| {
m.projects
.iter()
.any(|p| ide_core::project_roots::resolve(root, &root.join(&p.dir)) == *dir)
}))
})
});
let mut dirs: Vec<_> = maven.chain(gradle).collect();
dirs.dedup();
dirs
}
fn linked_config(
@@ -672,11 +698,59 @@ mod ownership_tests {
),
(
"linked module inside the root reactor belongs to the reactor",
vec![("pom.xml".into(), "<project></project>"), (format!("{deep}/pom.xml"), BOOT_POM)],
vec![
(
"pom.xml".into(),
"<project><modules><module>site/service/03_src/demo-monitor</module></modules></project>",
),
(format!("{deep}/pom.xml"), BOOT_POM),
],
vec!["site/service/03_src/demo-monitor/pom.xml"],
None,
vec!["maven:package".into(), "maven:test".into()],
),
(
"a separate Maven build linked inside the root build's folder has its own configurations",
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(),
format!("maven:package:{deep}"),
format!("maven:test:{deep}"),
format!("maven:spring-boot:run:{deep}"),
],
),
(
"a Gradle subproject linked as a build belongs to the root build",
vec![
("settings.gradle.kts".into(), "rootProject.name = \"root\"\ninclude(\"a:b:c:tool\")\n"),
("build.gradle.kts".into(), "plugins {\n java\n}"),
(format!("{tool}/build.gradle.kts"), "plugins {\n application\n}"),
],
vec![],
Some(vec![".", tool]),
vec!["gradle:build".into(), "gradle:test".into()],
),
(
"a separate Gradle build linked inside the root build's folder has its own configurations",
vec![
("settings.gradle.kts".into(), "rootProject.name = \"root\"\n"),
("build.gradle.kts".into(), "plugins {\n java\n}"),
(format!("{tool}/settings.gradle.kts"), "rootProject.name = \"tool\"\n"),
(format!("{tool}/build.gradle.kts"), "plugins {\n application\n}"),
],
vec![],
Some(vec![".", tool]),
vec![
"gradle:build".into(),
"gradle:test".into(),
format!("gradle:build:{tool}"),
format!("gradle:test:{tool}"),
format!("gradle:run:{tool}"),
],
),
(
"linked module within the search depth is not detected twice",
vec![("svc/pom.xml".into(), "<project></project>")],
+12 -12
Переглянути файл
@@ -34,9 +34,9 @@ pub struct ProjectInterpreter {
}
/// Installed interpreters / toolchains of `kind`; project-local ones first.
#[command(trust = trusted)]
#[command(trust = outside_restricted)]
pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<Vec<Sdk>> {
host.require_trust(window)?;
host.require_trust_if_project(window)?;
let project = host.project(window).ok();
if kind == SdkKind::Jdk {
host.apply_added_jdks();
@@ -63,10 +63,10 @@ pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<V
}
/// The Python interpreters of the recently opened projects, each with its project.
#[command(trust = trusted)]
#[command(trust = outside_restricted)]
pub async fn sdk_python_project_interpreters(host: &Host, window: &str) -> IdeResult<Vec<ProjectInterpreter>> {
// Newest first. The open project is skipped: `sdk_detect` lists its own.
host.require_trust(window)?;
host.require_trust_if_project(window)?;
let current = host.project(window).ok().map(|p| p.root.clone());
let config = host.config_dir.clone();
// Probing runs the project's interpreter (and its settings may name any program): only
@@ -111,9 +111,9 @@ pub async fn sdk_python_project_interpreters(host: &Host, window: &str) -> IdeRe
}
/// An existing Python executable or virtualenv folder as an SDK; `None` if Python cannot run.
#[command(trust = trusted)]
#[command(trust = outside_restricted)]
pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) -> IdeResult<Option<Sdk>> {
host.require_trust(window)?;
host.require_trust_if_project(window)?;
let root = host.project(window).ok().map(|p| p.root.clone());
tokio::task::spawn_blocking(move || Ok(ide_sdk::python_interpreter_sdk(&path, root.as_deref())))
.await
@@ -320,7 +320,7 @@ pub async fn sdk_locate_tools(
}
/// Creates a Python environment with `tool` (`venv` / `uv` / `poetry`); output streams through `on_output`.
#[command(trust = trusted)]
#[command(trust = outside_restricted)]
pub async fn sdk_python_create_venv(
host: &Host,
window: &str,
@@ -330,7 +330,7 @@ pub async fn sdk_python_create_venv(
request: RequestId,
on_output: Channel<String>,
) -> IdeResult<Sdk> {
host.require_trust(window)?;
host.require_trust_if_project(window)?;
let cancel = host.begin_project_request(window, request);
let result = tokio::task::spawn_blocking(move || {
ide_sdk::python::create_venv(tool, &base, &location, &cancel, &|line| {
@@ -343,14 +343,14 @@ pub async fn sdk_python_create_venv(
result?
}
#[command(trust = trusted)]
#[command(trust = outside_restricted)]
pub async fn sdk_python_packages(
host: &Host,
window: &str,
python: PathBuf,
request: RequestId,
) -> IdeResult<Vec<PythonPackage>> {
host.require_trust(window)?;
host.require_trust_if_project(window)?;
let cancel = host.begin_project_request(window, request);
let result =
tokio::task::spawn_blocking(move || ide_sdk::python::list_packages(&python, &cancel)).await.map_err(join_err);
@@ -360,7 +360,7 @@ pub async fn sdk_python_packages(
/// Installs (`uninstall = false`) or removes a package; output streams through `on_output`.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
#[command(trust = outside_restricted)]
pub async fn sdk_python_pip(
host: &Host,
window: &str,
@@ -371,7 +371,7 @@ pub async fn sdk_python_pip(
request: RequestId,
on_output: Channel<String>,
) -> IdeResult<()> {
host.require_trust(window)?;
host.require_trust_if_project(window)?;
let project_root = host.project(window).ok().map(|p| p.root.clone());
let cancel = host.begin_project_request(window, request);
let result = tokio::task::spawn_blocking(move || {
+6 -3
Переглянути файл
@@ -15,6 +15,9 @@ impl ReplaceHost for DocumentsHost<'_> {
Some(doc) => (doc, false),
None => (docs.open(path)?.id, true),
};
// A buffer without unsaved changes (open only for the search preview, or a clean
// tab) is saved like a closed file; one the user is editing is left unsaved.
let save = transient || !docs.is_dirty(doc)?;
let result = (|| {
// Recompute if the user typed between reading the text and applying.
for _ in 0..3 {
@@ -27,7 +30,7 @@ impl ReplaceHost for DocumentsHost<'_> {
continue;
}
docs.apply_edits(doc, &edits)?;
if transient {
if save {
docs.save(doc)?;
}
return Ok(edits.len() as u32);
@@ -46,8 +49,8 @@ impl ReplaceHost for DocumentsHost<'_> {
///
/// Edits go through the document layer as one patch per file, so open editors
/// 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.
/// editor buffers are replaced in place and left unsaved; other open documents
/// are saved, and 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,
+5 -5
Переглянути файл
@@ -11,7 +11,7 @@ use std::path::PathBuf;
/// The installer, reporting the executables chosen in the window's settings.
fn tools(host: &Host, window: &str) -> IdeResult<Tools> {
host.require_trust(window)?;
host.require_trust_if_project(window)?;
let data = host.local_data_dir.clone();
let (settings, root) = match host.project(window) {
Ok(project) => (project.settings.effective(), project.root.clone()),
@@ -56,7 +56,7 @@ fn reconfigure_servers(host: &Host) {
}
/// Status of every known language server / debug adapter and the languages using it.
#[command(trust = trusted)]
#[command(trust = outside_restricted)]
pub async fn tools_list(host: &Host, window: &str) -> IdeResult<Vec<ToolInfo>> {
let tools = tools(host, window)?;
let langs = languages(host, window);
@@ -65,7 +65,7 @@ pub async fn tools_list(host: &Host, window: &str) -> IdeResult<Vec<ToolInfo>> {
/// Installs (or reinstalls) a tool into `<app-data>/tools`, streaming output through
/// `on_event`. Cancel with `cancel_request(request)`.
#[command(trust = trusted)]
#[command(trust = outside_restricted)]
pub async fn tools_install(
host: &Host,
window: &str,
@@ -93,7 +93,7 @@ pub async fn tools_install(
/// Newer versions of the tools the IDE installed (release downloads and npm packages).
/// Cancel with `cancel_request(request)`.
#[command(trust = trusted)]
#[command(trust = outside_restricted)]
pub async fn tools_updates(host: &Host, window: &str, request: RequestId) -> IdeResult<Vec<ToolUpdate>> {
let tools = tools(host, window)?;
let cancel = host.begin_request(request);
@@ -103,7 +103,7 @@ pub async fn tools_updates(host: &Host, window: &str, request: RequestId) -> Ide
}
/// Removes a tool the IDE installed.
#[command(trust = trusted)]
#[command(trust = outside_restricted)]
pub async fn tools_uninstall(host: &Host, window: &str, name: String) -> IdeResult<ToolInfo> {
let tools = tools(host, window)?;
let langs = languages(host, window);
+10 -3
Переглянути файл
@@ -47,12 +47,19 @@ pub async fn serves_page(url: &str) -> bool {
response.status().is_success() && html
}
/// The built-in server's URL for `path` (started on first use).
/// The built-in server's URL for `path` (started on first use). A file whose language is
/// HTML (Settings › File Types can make it so) is served as a page, whatever its extension.
#[command(trust = always)]
pub async fn web_url(host: &Host, window: &str, path: IpcPath) -> IdeResult<String> {
// Under the window's project when it holds the file.
let root = host.project(window).ok().map(|p| p.root.clone());
host.web.url_for(root.as_deref(), &path).await
let project = host.project(window).ok();
let root = project.as_ref().map(|p| p.root.as_path());
let languages = project.as_ref().map_or(&host.languages, |p| &p.languages);
if matches!(languages.detect(&path, None).as_str(), "html" | "django-html") {
host.web.page_url_for(root, &path).await
} else {
host.web.url_for(root, &path).await
}
}
#[cfg(test)]
+3 -1
Переглянути файл
@@ -162,7 +162,8 @@ impl PluginHost {
.collect()
}
/// What a plugin receives for `document-changed`: the path relative to the file's own project.
/// What a plugin receives for `document-changed`: the path relative to the file's own
/// project, and that project's root, since two open projects can hold the same relative path.
pub(super) fn relativize_documents(
shared: &super::api::Shared,
client: Option<&str>,
@@ -181,6 +182,7 @@ impl PluginHost {
.to_string_lossy()
.replace('\\', "/");
change.path = relative;
change.project = Some(ide_core::ipc_path::to_ipc(&root));
Some(WorkbenchEvent::DocumentChanged(change))
})
.collect()
+36 -5
Переглянути файл
@@ -272,6 +272,7 @@ impl Host {
lombok.jar(),
);
ide_sdk::apply::configure_gradle_runtime(cfg, root, server_root, &effective);
ide_sdk::apply::configure_maven_sources(cfg, &effective);
ide_sdk::jdtls::launch_directly(cfg);
}
ide_sdk::apply::server_protocol_overrides(cfg, &effective);
@@ -285,6 +286,8 @@ impl Host {
effective.languages.java.gradle.linked_projects.as_deref(),
build_files.as_deref(),
);
// After the import settings: they extend the workspace folder's name.
ide_sdk::jdtls_workspaces::use_own_temp(cfg, &data_dir);
}
}));
}
@@ -321,7 +324,7 @@ impl Host {
let syntax = Arc::new(SyntaxCache::new(self.syntax()));
documents.add_observer(Arc::new(SyntaxObserver(syntax.clone())));
documents.add_observer(Arc::new(LspObserver(lsp.clone())));
documents.add_observer(Arc::new(HistoryObserver(history.clone())));
documents.add_observer(Arc::new(HistoryObserver::new(history.clone())));
documents.add_observer(Arc::new(DeployObserver {
remote: self.remote.clone(),
settings: settings.clone(),
@@ -782,7 +785,7 @@ impl Host {
lsp.set_servers_hook(Box::new(|_, _| Vec::new()));
let syntax = Arc::new(SyntaxCache::new(self.syntax()));
documents.add_observer(Arc::new(SyntaxObserver(syntax.clone())));
documents.add_observer(Arc::new(HistoryObserver(history.clone())));
documents.add_observer(Arc::new(HistoryObserver::new(history.clone())));
let watcher = match watch_dir {
Some(dir) => light_watcher(dir, &sink, &documents, &history)?,
// A quiet private folder stands in until the first save brings a
@@ -1887,14 +1890,42 @@ impl DocumentObserver for SyntaxObserver {
}
}
struct HistoryObserver(Arc<LocalHistory>);
struct HistoryObserver {
history: Arc<LocalHistory>,
/// Documents edited since they were opened: only the first edit looks for a missing original.
edited: Mutex<HashSet<ide_core::DocId>>,
}
impl HistoryObserver {
fn new(history: Arc<LocalHistory>) -> Self {
Self { history, edited: Mutex::default() }
}
}
impl DocumentObserver for HistoryObserver {
fn saved(&self, _doc: ide_core::DocId, path: &Path, text: &str) {
if let Err(e) = self.0.record(path, text, "Saved") {
fn changed(
&self,
doc: ide_core::DocId,
path: &Path,
_version: u32,
_changes: &[AppliedChange],
_full_text: &dyn Fn() -> String,
) {
// The file on disk still has its content from before the edit.
if self.edited.lock().insert(doc)
&& let Err(e) = self.history.record_original(path)
{
tracing::warn!("local history: {e}");
}
}
fn saved(&self, _doc: ide_core::DocId, path: &Path, text: &str) {
if let Err(e) = self.history.record(path, text, "Saved") {
tracing::warn!("local history: {e}");
}
}
fn closed(&self, doc: ide_core::DocId, _path: &Path) {
self.edited.lock().remove(&doc);
}
}
/// Uploads saved files: remote files' local copies, and automatic upload to the default server.
+14 -5
Переглянути файл
@@ -879,16 +879,15 @@ fn background_tasks_scale_and_renew_cpu_fuel_budget() {
// Room for activation (about 3_100 on macOS, more on Windows). A background task gets ten
// times it (5 s / 500 ms): enough for each step of `patient` with its CPU work (32_000 to
// 80_000), not for the whole run without the refill on each report.
let f = fixture(Limits {
let limits = Limits {
fuel: 40_000,
timeout: Duration::from_millis(500),
background: Duration::from_millis(5_000),
..Limits::default()
});
};
let f = fixture(limits);
f.install(&misbehave_pkg());
if f.host.set_capability("misbehave", "process:git", true).is_err() {
return;
}
f.host.set_capability("misbehave", "process:git", true).expect("grant Git capability");
// Warm up activation in its own call so `patient` starts with a fresh budget.
assert_eq!(f.run("misbehave", "echo", Some("warm")).unwrap().as_deref(), Some("warm"));
@@ -897,6 +896,13 @@ fn background_tasks_scale_and_renew_cpu_fuel_budget() {
let err = f.run("misbehave", "spin", None).unwrap_err();
assert!(err.contains("exceeded its CPU budget (40000 fuel per call)"), "{err}");
// Beginning a task alone must not renew its scaled budget.
let quiet = fixture(limits);
quiet.install(&misbehave_pkg());
quiet.host.set_capability("misbehave", "process:git", true).expect("grant Git capability");
let err = quiet.run("misbehave", "patient", Some("quiet:4000")).unwrap_err();
assert!(err.contains("exceeded its CPU budget (400000 fuel per call)"), "{err}");
}
#[test]
@@ -5292,6 +5298,7 @@ fn document_changes_reach_plugins_relative_to_the_project() {
let deliver = |path: &str| {
let change = ide_plugin::DocumentChanged {
path: to_ipc(&f.project.join(path)),
project: None,
base_version: 1,
version: 2,
changes: Vec::new(),
@@ -5305,6 +5312,8 @@ fn document_changes_reach_plugins_relative_to_the_project() {
// 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"));
// With the project it is relative to: another open project may hold the same path.
assert_eq!(f.run("test.path-events", "document-project", None).unwrap(), Some(to_ipc(&f.project)));
}
#[test]
+49
Переглянути файл
@@ -146,3 +146,52 @@ async fn replace_all_covers_matches_past_the_limit() {
host.close_project("main");
}
}
/// #4202: a file the search preview holds open (no unsaved changes) is saved like a closed
/// one; a buffer with unsaved edits is replaced in place and left for the editor to save.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn replace_all_saves_open_buffers_without_unsaved_changes() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("project");
std::fs::create_dir_all(&root).unwrap();
for name in ["previewed.txt", "edited.txt", "closed.txt"] {
std::fs::write(root.join(name), "TOKEN\n").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 project = host.project("main").unwrap();
project.documents.open(&root.join("previewed.txt")).unwrap();
let edited = project.documents.open(&root.join("edited.txt")).unwrap().id;
project.documents.replace_all(edited, "TOKEN\nmore\n").unwrap();
ops::search::replace_in_files(
&host,
"main",
RequestId::next(),
query("TOKEN", false),
"DONE".into(),
false,
vec![],
true,
ops::Channel::new(|_| {}),
)
.await
.unwrap();
let disk = |name: &str| std::fs::read_to_string(root.join(name)).unwrap();
assert_eq!(disk("previewed.txt"), "DONE\n");
assert_eq!(disk("closed.txt"), "DONE\n");
assert_eq!(disk("edited.txt"), "TOKEN\n", "unsaved edits stay unsaved");
assert_eq!(project.documents.text_snapshot(edited).unwrap().text, "DONE\nmore\n");
host.close_project("main");
}
+3
Переглянути файл
@@ -45,6 +45,9 @@ async fn a_commands_trust_class_decides_where_it_runs() {
assert_eq!(allowed("main", class), in_restricted, "{class:?} in Restricted Mode");
assert_eq!(allowed("welcome", class), without_project, "{class:?} without a project");
}
// Toolchain detection runs from Settings opened on the Welcome screen, but not in Restricted Mode.
assert!(ide_host::ops::sdk::sdk_detect(&host, "welcome", ide_sdk::SdkKind::Zig).await.is_ok());
assert!(ide_host::ops::sdk::sdk_detect(&host, "main", ide_sdk::SdkKind::Zig).await.is_err());
// These requests validate the vendor before any network access, independently of project trust.
let error = ide_host::ops::tools::jdk_download_releases(&host, "unknown-vendor".into(), ide_core::RequestId(901))
.await
+1 -1
Переглянути файл
@@ -28,7 +28,7 @@ pub use syntax::{
VueComponentImport, VueRefAccess, VueRefElement, WebReference, WebReferenceKind, merge_visibility,
set_external_syntax, shift_pos, shift_range,
};
pub use syntax::{MethodBody, PythonClassFacts, PythonFacts, PythonMethodFacts};
pub use syntax::{MethodBody, PhpAlignment, PythonClassFacts, PythonFacts, PythonMethodFacts};
/// Parsed form of `languages/<id>.toml`. Backend-only; the UI gets [`LanguageInfo`].
#[derive(Clone, Debug, Serialize, Deserialize)]
+2
Переглянути файл
@@ -10,6 +10,7 @@ mod inheritance;
pub(crate) mod lines;
mod literals;
mod outline;
mod php_align;
mod python_facts;
mod rst;
mod selection;
@@ -28,6 +29,7 @@ pub use inheritance::ClassBases;
pub use lines::{shift_pos, shift_range};
pub use literals::{Literal, LiteralKind, SpellingKind, SpellingRegion};
pub use outline::merge_visibility;
pub use php_align::PhpAlignment;
pub use python_facts::{MethodBody, PythonClassFacts, PythonFacts, PythonMethodFacts};
use std::cell::RefCell;
use std::collections::HashMap;
+368
Переглянути файл
@@ -0,0 +1,368 @@
//! PHP Code Style › Align key-value pairs and Align consecutive assignments (PhpStorm's
//! options of the same names), applied to text a formatter has already formatted.
//!
//! A block is a run of array elements, or of assignment statements, on consecutive lines of
//! the same array or statement list, one per line and each on a single line. A blank line,
//! a comment line, another statement or element, or one spanning several lines ends it.
//! Within a block the operators line up one space after the longest left-hand side; nested
//! arrays form blocks of their own. Only the whitespace before an operator token of the
//! syntax tree changes, so `=>` and `=` inside strings and comments are never touched.
use crate::{LanguageId, Syntax};
use tree_sitter::{Node, Tree};
/// Which alignments to apply.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct PhpAlignment {
/// `=>` of the elements of multi-line arrays.
pub key_value_pairs: bool,
/// `=` of consecutive assignment statements.
pub assignments: bool,
}
impl PhpAlignment {
pub fn any(self) -> bool {
self.key_value_pairs || self.assignments
}
}
impl Syntax {
/// `text` with its PHP alignment applied, changing only lines `lines` (0-based, inclusive;
/// `None`: all). A block reaching outside them still aligns with its lines there.
/// `None` when nothing changes or `lang` is not parsed with the PHP grammar.
pub fn align_php(
&self,
lang: &LanguageId,
text: &str,
lines: Option<(usize, usize)>,
options: PhpAlignment,
) -> Option<String> {
if !options.any() {
return None;
}
self.analyze(lang, text, |g, tree, text| (g.spec.name == "php").then(|| align(tree, text, lines, options)))
.flatten()
}
}
/// One line's operator: the whitespace `gap` before it and the width of the line up to it.
#[derive(Clone, Copy, Debug)]
struct Entry {
line: usize,
gap: (usize, usize),
/// Characters from the start of the line to the end of the left-hand side.
width: usize,
}
fn align(tree: &Tree, text: &str, lines: Option<(usize, usize)>, options: PhpAlignment) -> Option<String> {
let mut gaps: Vec<(usize, usize, usize)> = Vec::new();
let mut cursor = tree.walk();
visit(&mut cursor, &mut |node| {
// Error recovery can read string content as code, where whitespace matters.
if node.is_error() {
return;
}
let entries = match node.kind() {
"array_creation_expression" if options.key_value_pairs => run(node, text, key_value),
_ if options.assignments => run(node, text, assignment),
_ => return,
};
for block in blocks(&entries) {
let column = block.iter().map(|e| e.width).max().unwrap_or(0) + 1;
for e in block {
if lines.is_none_or(|(first, last)| (first..=last).contains(&e.line)) {
gaps.push((e.gap.0, e.gap.1, column - e.width));
}
}
}
});
gaps.sort_unstable();
let mut out = String::with_capacity(text.len());
let mut at = 0;
let mut changed = false;
for (from, to, spaces) in gaps {
if text[from..to].len() == spaces && text[from..to].bytes().all(|b| b == b' ') {
continue;
}
out.push_str(&text[at..from]);
out.extend(std::iter::repeat_n(' ', spaces));
at = to;
changed = true;
}
if !changed {
return None;
}
out.push_str(&text[at..]);
Some(out)
}
/// The named children of `parent` as alignment candidates in order: `None` breaks a block.
/// A comment ending the line of the child before it (`'a' => 1, // why`) is skipped; two
/// children sharing a line are both left alone.
fn run(parent: Node, text: &str, entry: fn(Node, &str) -> Option<Entry>) -> Vec<Option<Entry>> {
let mut out: Vec<Option<Entry>> = Vec::new();
let mut previous_end: Option<usize> = None;
let mut cursor = parent.walk();
for child in parent.named_children(&mut cursor) {
let start = child.start_position().row;
let shares_line = previous_end == Some(start);
if child.kind() == "comment" && shares_line {
continue;
}
if shares_line && let Some(last) = out.last_mut() {
*last = None;
}
out.push(if shares_line { None } else { entry(child, text) });
previous_end = Some(child.end_position().row);
}
out
}
/// Runs of entries on consecutive lines.
fn blocks(entries: &[Option<Entry>]) -> Vec<Vec<Entry>> {
let mut out: Vec<Vec<Entry>> = Vec::new();
let mut current: Vec<Entry> = Vec::new();
for entry in entries {
match entry {
Some(e) if current.last().is_none_or(|last| last.line + 1 == e.line) => current.push(*e),
Some(e) => out.push(std::mem::replace(&mut current, vec![*e])),
None if current.is_empty() => {}
None => out.push(std::mem::take(&mut current)),
}
}
if !current.is_empty() {
out.push(current);
}
out
}
/// `'key' => value` alone on one line.
fn key_value(element: Node, text: &str) -> Option<Entry> {
if element.kind() != "array_element_initializer" {
return None;
}
let mut cursor = element.walk();
let arrow = element.children(&mut cursor).find(|c| c.kind() == "=>")?;
let key = arrow.prev_sibling()?;
entry(element, key, arrow, text)
}
/// `$left = value;` (or `= &value`) alone on one line.
fn assignment(statement: Node, text: &str) -> Option<Entry> {
if statement.kind() != "expression_statement" {
return None;
}
let expression = statement.named_child(0)?;
if !matches!(expression.kind(), "assignment_expression" | "reference_assignment_expression") {
return None;
}
let left = expression.child_by_field_name("left")?;
let mut cursor = expression.walk();
let operator = expression.children(&mut cursor).find(|c| c.kind() == "=")?;
entry(statement, left, operator, text)
}
fn entry(whole: Node, left: Node, operator: Node, text: &str) -> Option<Entry> {
let line = whole.start_position().row;
if whole.has_error() || whole.end_position().row != line {
return None;
}
let line_start = whole.start_byte() - whole.start_position().column;
let starts_line = text[line_start..whole.start_byte()].bytes().all(|b| b == b' ' || b == b'\t');
let gap = (left.end_byte(), operator.start_byte());
let blank_gap = text[gap.0..gap.1].bytes().all(|b| b == b' ' || b == b'\t');
(starts_line && blank_gap).then(|| Entry { line, gap, width: text[line_start..gap.0].chars().count() })
}
fn visit(cursor: &mut tree_sitter::TreeCursor, f: &mut impl FnMut(Node)) {
loop {
f(cursor.node());
if cursor.goto_first_child() {
continue;
}
loop {
if cursor.goto_next_sibling() {
break;
}
if !cursor.goto_parent() {
return;
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::OnceLock;
const BOTH: PhpAlignment = PhpAlignment { key_value_pairs: true, assignments: true };
const PAIRS: PhpAlignment = PhpAlignment { key_value_pairs: true, assignments: false };
const ASSIGNMENTS: PhpAlignment = PhpAlignment { key_value_pairs: false, assignments: true };
fn syntax() -> &'static Syntax {
static S: OnceLock<Syntax> = OnceLock::new();
S.get_or_init(Syntax::new)
}
fn aligned(text: &str, lines: Option<(usize, usize)>, options: PhpAlignment) -> String {
let out = syntax().align_php(&LanguageId::new("php"), text, lines, options);
let result = out.clone().unwrap_or_else(|| text.to_owned());
let strip = |s: &str| s.chars().filter(|c| !c.is_whitespace()).collect::<String>();
assert_eq!(strip(&result), strip(text), "only whitespace changes");
assert_eq!(
syntax().align_php(&LanguageId::new("php"), &result, lines, options),
None,
"aligning again changes nothing:\n{result}"
);
result
}
fn check(options: PhpAlignment, before: &str, after: &str) {
assert_eq!(aligned(before, None, options), after);
}
#[test]
fn aligns_the_arrows_of_a_multi_line_array() {
check(
PAIRS,
"<?php\nreturn [\n 'name' => 'demo',\n 'description' => 'x',\n 'id' => 1,\n];\n",
"<?php\nreturn [\n 'name' => 'demo',\n 'description' => 'x',\n 'id' => 1,\n];\n",
);
check(
PAIRS,
"<?php\n$a = array(\n 1 => 'a',\n 1234 => 'b',\n);\n",
"<?php\n$a = array(\n 1 => 'a',\n 1234 => 'b',\n);\n",
);
}
#[test]
fn nested_arrays_align_per_level_and_a_multi_line_value_ends_a_block() {
check(
PAIRS,
"<?php\n$config = [\n 'a' => 1,\n 'bbb' => 2,\n 'nested' => [\n 'x' => 1,\n 'yyyy' => 2,\n ],\n 'c' => 3,\n 'dd' => 4,\n];\n",
"<?php\n$config = [\n 'a' => 1,\n 'bbb' => 2,\n 'nested' => [\n 'x' => 1,\n 'yyyy' => 2,\n ],\n 'c' => 3,\n 'dd' => 4,\n];\n",
);
}
#[test]
fn blank_lines_comment_lines_and_elements_without_a_key_end_a_block() {
check(
PAIRS,
"<?php\n$a = [\n 'a' => 1,\n 'bb' => 2,\n\n 'ccc' => 3,\n // section\n 'dddd' => 4,\n 'e' => 5,\n 6,\n 'ff' => 7,\n];\n",
"<?php\n$a = [\n 'a' => 1,\n 'bb' => 2,\n\n 'ccc' => 3,\n // section\n 'dddd' => 4,\n 'e' => 5,\n 6,\n 'ff' => 7,\n];\n",
);
}
#[test]
fn a_comment_at_the_end_of_a_line_keeps_the_block() {
check(
PAIRS,
"<?php\n$a = [\n 'a' => 1, // first\n 'bb' => 2, /* second */\n 'ccc' => 3,\n];\n",
"<?php\n$a = [\n 'a' => 1, // first\n 'bb' => 2, /* second */\n 'ccc' => 3,\n];\n",
);
}
#[test]
fn single_line_arrays_and_elements_sharing_a_line_stay_as_they_are() {
for text in [
"<?php\n$a = ['a' => 1, 'bbb' => 2];\n",
"<?php\n$a = [\n 'a' => 1, 'bbb' => 2,\n 'cc' => 3,\n];\n",
"<?php\n$a = ['a' => 1,\n 'bbb' => 2];\n",
] {
assert_eq!(aligned(text, None, BOTH), text);
}
}
#[test]
fn arrows_and_equals_signs_outside_arrays_and_assignments_are_not_touched() {
let text = "<?php\n\
$s = 'a => b';\n\
$t = \"x = y\";\n\
// 'k' => 1, $v = 2\n\
/* 'kk' => 1 */\n\
foreach ($items as $key => $value) {}\n\
$f = fn($x) => $x;\n\
$m = match ($x) {\n 1 => 'a',\n 100 => 'b',\n};\n\
for ($i = 0; $i < 3; $i++) {}\n\
function g($a = 1, $bbb = 2) {}\n\
g(a: 1, bbb: 2);\n\
$h = <<<EOT\n 'a' => 1,\n 'bbb' => 2,\nEOT;\n";
let out = aligned(text, None, PAIRS);
assert_eq!(out, text);
}
#[test]
fn aligns_consecutive_assignments() {
check(
ASSIGNMENTS,
"<?php\n$y = foo($x);\n$i = foo($i);\n$result = $result . $y . $i;\n$this->name = 'n';\n$ref = &$y;\n",
"<?php\n$y = foo($x);\n$i = foo($i);\n$result = $result . $y . $i;\n$this->name = 'n';\n$ref = &$y;\n",
);
}
#[test]
fn other_statements_blank_lines_and_multi_line_assignments_end_a_block() {
check(
ASSIGNMENTS,
"<?php\nfunction f() {\n $a = 1;\n $bb = 2;\n echo $a;\n $ccc = 3;\n $d = 4;\n\n $eeeee = 5;\n $f = 6;\n $g .= 'x';\n $hh = 7;\n $i = [\n 1,\n ];\n $jjj = 8;\n $k = 9;\n}\n",
"<?php\nfunction f() {\n $a = 1;\n $bb = 2;\n echo $a;\n $ccc = 3;\n $d = 4;\n\n $eeeee = 5;\n $f = 6;\n $g .= 'x';\n $hh = 7;\n $i = [\n 1,\n ];\n $jjj = 8;\n $k = 9;\n}\n",
);
}
#[test]
fn assignments_sharing_a_line_and_declarations_stay_as_they_are() {
let text = "<?php\n$a = 1; $bbb = 2;\n$cc = 3;\nclass C {\n public $x = 1;\n public $yyy = 2;\n const A = 1;\n const BBB = 2;\n}\n";
assert_eq!(aligned(text, None, ASSIGNMENTS), text);
}
#[test]
fn each_option_aligns_only_its_operator() {
let text = "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n$x = 1;\n$yyy = 2;\n";
assert_eq!(
aligned(text, None, PAIRS),
"<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n$x = 1;\n$yyy = 2;\n"
);
assert_eq!(
aligned(text, None, ASSIGNMENTS),
"<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n$x = 1;\n$yyy = 2;\n"
);
assert_eq!(syntax().align_php(&LanguageId::new("php"), text, None, PhpAlignment::default()), None);
assert_eq!(syntax().align_php(&LanguageId::new("javascript"), "a = {\n b: 1,\n};\n", None, BOTH), None);
}
#[test]
fn only_the_given_lines_change_and_they_align_with_the_whole_block() {
let text = "<?php\n$a = [\n 'a' => 1,\n 'bb' => 2,\n 'cccc' => 3,\n];\n";
assert_eq!(
aligned(text, Some((2, 3)), PAIRS),
"<?php\n$a = [\n 'a' => 1,\n 'bb' => 2,\n 'cccc' => 3,\n];\n"
);
assert_eq!(aligned(text, Some((5, 5)), PAIRS), text);
}
#[test]
fn widths_count_characters_not_bytes() {
check(
PAIRS,
"<?php\n$a = [\n '名前' => 1,\n 'name' => 2,\n];\n",
"<?php\n$a = [\n '名前' => 1,\n 'name' => 2,\n];\n",
);
}
#[test]
fn code_with_syntax_errors_is_aligned_only_where_it_parses() {
let text = "<?php\n$a = [\n 'a' => 1,\n 'bbb' => ,\n 'cc' => 3,\n];\n";
let out = aligned(text, None, PAIRS);
assert!(out.contains("'bbb' => ,"), "{out}");
}
#[test]
fn php_inside_html() {
check(
BOTH,
"<html>\n<?php\n$a = 1;\n$bbb = 2;\n?>\n<p>x = y</p>\n",
"<html>\n<?php\n$a = 1;\n$bbb = 2;\n?>\n<p>x = y</p>\n",
);
}
}
+61
Переглянути файл
@@ -65,6 +65,28 @@ pub(crate) fn lenient_diagnostics(server: &str, items: Value) -> Vec<lsp::Diagno
parsed
}
/// rust-analyzer publishes its own analysis next to `cargo check`'s (flycheck): one type
/// mismatch then arrives as `rust-analyzer(E0308)` and `rustc(E0308)`. Its own entry is
/// dropped when the compiler reports the same code and severity over an overlapping range.
fn drop_compiler_duplicates(diagnostics: &mut Vec<lsp::Diagnostic>) {
let overlaps = |a: &lsp::Range, b: &lsp::Range| a.start <= b.end && b.start <= a.end;
let compiler: Vec<(lsp::Range, Option<lsp::NumberOrString>, Option<lsp::DiagnosticSeverity>)> = diagnostics
.iter()
.filter(|d| d.source.as_deref() == Some("rustc") && d.code.is_some())
.map(|d| (d.range, d.code.clone(), d.severity))
.collect();
if compiler.is_empty() {
return;
}
diagnostics.retain(|d| {
d.source.as_deref() != Some("rust-analyzer")
|| d.code.is_none()
|| !compiler
.iter()
.any(|(range, code, severity)| code == &d.code && severity == &d.severity && overlaps(range, &d.range))
});
}
impl ClientHandler {
pub fn new(mgr: Weak<LspManager>, server: Arc<Server>, generation: u64) -> Self {
Self { mgr, server, generation }
@@ -293,11 +315,20 @@ impl ClientHandler {
}
};
params.diagnostics = lenient_diagnostics(&self.server.name, raw.unwrap_or(Value::Null));
drop_compiler_duplicates(&mut params.diagnostics);
let Some(path) = uri_to_path(params.uri.as_str())
.or_else(|| crate::notebook::is_cell_uri(params.uri.as_str()).then(|| PathBuf::from(params.uri.as_str())))
else {
return;
};
if self.server.name == crate::compose::SERVER {
// Maven resource-filtering placeholders (`@profileActive@`) parse as invalid
// YAML but are replaced before the file is ever read: their parser error is noise.
let text = mgr.docs.lock().values().find(|d| d.path == path).map(|d| d.text.as_str().to_owned());
if let Some(text) = text {
params.diagnostics.retain(|d| !crate::maven_placeholder::false_positive(&text, d));
}
}
if self.server.name == "jdtls"
&& let Some(failure) = crate::jdtls::build_plan_failure(&path, &self.server.root, &params.diagnostics)
{
@@ -435,6 +466,14 @@ impl ClientHandler {
.find_map(|base| section.split('.').try_fold(base, |v, key| v.get(key)))
.cloned()
.unwrap_or(Value::Null),
None if self.server.name == "eslint" => {
let mut settings = options.clone();
settings["workspaceFolder"] = json!({
"uri": crate::uri::path_to_uri(&self.server.root),
"name": self.server.root.file_name().map_or_else(|| "root".into(), |name| name.to_string_lossy().into_owned()),
});
settings
}
None => options.clone(),
})
.collect(),
@@ -693,6 +732,28 @@ mod tests {
use std::path::PathBuf;
use std::sync::{Arc, Mutex};
#[test]
fn rust_analyzer_s_own_entry_yields_to_the_compiler_s_for_the_same_error() {
let diagnostic = |source: &str, code: &str, line: u32, severity| lsp::Diagnostic {
range: lsp::Range::new(lsp::Position::new(line, 21), lsp::Position::new(line, 27)),
severity: Some(severity),
code: Some(lsp::NumberOrString::String(code.into())),
source: Some(source.into()),
message: format!("{source} {code}"),
..Default::default()
};
let error = lsp::DiagnosticSeverity::ERROR;
let mut items = vec![
diagnostic("rust-analyzer", "E0308", 1, error),
diagnostic("rustc", "E0308", 1, error),
diagnostic("rust-analyzer", "E0308", 5, error),
diagnostic("rust-analyzer", "unused_variables", 1, lsp::DiagnosticSeverity::WARNING),
];
drop_compiler_duplicates(&mut items);
let left: Vec<_> = items.iter().map(|d| (d.message.as_str(), d.range.start.line)).collect();
assert_eq!(left, [("rustc E0308", 1), ("rust-analyzer E0308", 5), ("rust-analyzer unused_variables", 1)]);
}
#[test]
fn tsserver_aborts_are_out_of_memory() {
assert!(tsserver_ran_out_of_memory("TSServer exited. Code: 134. Signal: null"));
+45 -14
Переглянути файл
@@ -25,6 +25,7 @@ mod kotlin_lsp;
mod launch;
mod library_source;
mod loading;
mod maven_placeholder;
mod message_requests;
mod notebook;
mod phoxite;
@@ -1833,8 +1834,11 @@ impl LspManager {
/// the same class from its Java model instead, decompiled with method bodies and navigable.
/// Its documents belong to jdtls ([`Self::virtual_document`] records it).
async fn jdt_library_classes(&self, snap: &DocSnap, pos: Pos, locs: Vec<Location>) -> Vec<Location> {
let jar_class = |l: &Location| l.uri.as_deref().is_some_and(|u| u.starts_with("jar:") && u.ends_with(".class"));
if !locs.iter().any(jar_class)
let lib_class = |u: &str| {
(u.starts_with("jar:") && u.ends_with(".class"))
|| (u.starts_with("jdt://contents/") && u.contains(".class"))
};
if !locs.iter().any(|l| l.uri.as_deref().is_some_and(lib_class))
|| !self.servers.lock().iter().any(|s| s.name == jdtls::SERVER && s.running().is_some())
{
return locs;
@@ -1842,27 +1846,54 @@ impl LspManager {
let name = library_source::identifier_at(snap.text.line(pos.line as usize), pos.col).map(str::to_owned);
let mut out = Vec::with_capacity(locs.len());
for loc in locs {
let entry = loc.uri.as_deref().filter(|_| jar_class(&loc)).and_then(library_source::parse);
let Some(entry) = entry else {
let Some(original) = loc.uri.as_deref().filter(|u| lib_class(u)) else {
out.push(loc);
continue;
};
// The Kotlin server may name the jar by another path than jdtls (its own copy of a
// `system`-scope jar): its stub would be all the user gets, so take jdtls' only class
// of that name.
let uri = match self.archive_class(entry.jar, entry.entry, true).await {
Ok(uri) => uri,
Err(e) => {
tracing::info!("library class stays a stub: {}", e.message);
let jdt = original.starts_with("jdt:");
let uri = if !jdt {
let Some(entry) = library_source::parse(original) else {
out.push(loc);
continue;
};
// The Kotlin server may name the jar by another path than jdtls (its own copy of a
// `system`-scope jar): its stub would be all the user gets, so take jdtls' only class
// of that name.
match self.archive_class(entry.jar, entry.entry, true).await {
Ok(uri) => uri,
Err(e) => {
tracing::info!("library class stays a stub: {}", e.message);
out.push(loc);
continue;
}
}
} else {
original.to_owned()
};
let range = match (&name, self.virtual_document(&uri).await) {
(Some(name), Ok(doc)) => library_source::declaration_range(&doc.text, name),
let doc = self.virtual_document(&uri).await.ok();
let range = match (&name, &doc) {
// jdtls' own class: its range is exact (overloads included) unless it maps a
// Lombok-generated member onto the annotation or class header, which doesn't
// name the member; only then look the declaration up in the source.
(Some(name), Some(doc)) if jdt => {
let line = doc.text.lines().nth(loc.range.start.line as usize).unwrap_or_default();
if library_source::identifier_at(line, loc.range.start.col) == Some(name.as_str()) {
loc.range
} else {
Some(library_source::declaration_range(&doc.text, name))
.filter(|r| *r != Range::default())
.unwrap_or(loc.range)
}
}
(Some(name), Some(doc)) => library_source::declaration_range(&doc.text, name),
_ if jdt => loc.range,
_ => Range::default(),
};
out.push(Location { path: uri.clone().into(), range, uri: Some(uri) });
out.push(if jdt {
Location { range, ..loc }
} else {
Location { path: uri.clone().into(), range, uri: Some(uri) }
});
}
out
}
+62 -1
Переглянути файл
@@ -180,6 +180,7 @@ pub(crate) fn declaration_range(text: &str, name: &str) -> Range {
const KEYWORDS: [&str; 9] = ["fun", "class", "interface", "object", "val", "var", "typealias", "enum", "record"];
let is_ident = |c: char| c.is_alphanumeric() || c == '_' || c == '$';
let mut fallback = None;
let mut field = None;
let mut block_comment = false;
for (line_no, line) in text.lines().enumerate() {
let trimmed = line.trim_start();
@@ -223,9 +224,40 @@ pub(crate) fn declaration_range(text: &str, name: &str) -> Range {
if java_member && fallback.is_none() {
fallback = Some(range);
}
// A Java field (`private String name;`, `int age = 5;`): Lombok sources declare only
// the field, the accessors exist solely in the compiled class. A method of that name
// still wins, so a same-named local declared before it is not taken.
let java_field = matches!(line[end..].trim_start().chars().next(), Some(';' | '=' | ','))
&& !head.trim_end().ends_with('.')
&& !head.trim().is_empty()
&& !head.contains(['=', '('])
&& !words.iter().any(|w| matches!(*w, "return" | "throw" | "new" | "yield" | "assert"));
if java_field && field.is_none() {
field = Some(range);
}
}
}
fallback.unwrap_or_default()
if let Some(range) = fallback.or(field) {
return range;
}
accessor_field(name).map(|field| declaration_range(text, &field)).unwrap_or_default()
}
/// The field a Lombok/bean accessor stands for (`getName`/`setName` → `name`,
/// `isActive` → `active`); `None` for names that are not accessors.
fn accessor_field(name: &str) -> Option<String> {
let rest = ["get", "set", "is"]
.iter()
.find_map(|p| name.strip_prefix(p))
.filter(|r| r.chars().next().is_some_and(|c| c.is_uppercase()))?;
let mut chars = rest.chars();
let first = chars.next()?;
// Bean convention: `getURL` → `URL`, `getName` → `name`.
if rest.chars().nth(1).is_some_and(|c| c.is_uppercase()) {
Some(rest.to_owned())
} else {
Some(first.to_lowercase().collect::<String>() + chars.as_str())
}
}
/// The identifier around `col` (UTF-16) of `line`.
@@ -588,6 +620,35 @@ mod tests {
assert_eq!(declared_package("class A"), "");
}
#[test]
fn lombok_accessors_and_java_fields_locate_the_field() {
// Lombok sources declare only the field; the accessors exist only in the
// compiled class, so navigation must fall back to the underlying field.
let lombok = "package example.entity;\n\nimport lombok.Getter;\nimport lombok.Setter;\n\n@Getter\n@Setter\npublic class UserEntity {\n private String name;\n private int age;\n private boolean active;\n}\n";
for (name, line, col) in [
("getName", 8, 19),
("setName", 8, 19),
("name", 8, 19),
("getAge", 9, 16),
("isActive", 10, 20),
("active", 10, 20),
] {
let r = declaration_range(lombok, name);
assert_eq!((r.start.line, r.start.col), (line, col), "{name}");
}
// An explicitly declared accessor still wins over the field.
let plain = "class Plain {\n private String name;\n public String getName() { return name; }\n}\n";
assert_eq!(declaration_range(plain, "getName").start.line, 2);
// Initialized fields count; a method beats a same-named local declared before it.
let init = "class Init {\n private int count = 0;\n void a() {\n int size = 1;\n }\n int size() { return 2; }\n}\n";
assert_eq!(declaration_range(init, "getCount").start.line, 1);
assert_eq!(declaration_range(init, "size").start.line, 5);
// Bean convention keeps acronyms; non-accessors are not remapped.
assert_eq!(accessor_field("getURL").as_deref(), Some("URL"));
assert_eq!(accessor_field("getter"), None);
assert_eq!(declaration_range(lombok, "missing"), Range::default());
}
#[test]
fn locates_declarations_in_kotlin_and_java_sources() {
let at = |text: &str, name: &str| {
+113
Переглянути файл
@@ -0,0 +1,113 @@
//! `@property@` placeholders in YAML resources: Maven resource filtering replaces
//! them before the file is ever read as YAML, so Spring projects use them unquoted
//! (`spring.profiles.active: @profileActive@`). The YAML spec reserves `@` and the
//! `yaml` parser behind `yaml-language-server` therefore reports
//! "Plain value cannot start with reserved character @" for every one of them.
//! The diagnostic is dropped when the reported scalar is exactly a Maven
//! placeholder; anything else the parser flags keeps showing.
use lsp_types as lsp;
const RESERVED_AT: &str = "Plain value cannot start with reserved character @";
/// Whether `diagnostic` is the reserved-`@` parser error on a scalar whose text in
/// `text` is exactly a Maven placeholder (`@token@`).
pub(crate) fn false_positive(text: &str, diagnostic: &lsp::Diagnostic) -> bool {
diagnostic.message == RESERVED_AT && placeholder_at(text, &diagnostic.range).is_some()
}
/// The name between the `@`s of the diagnostic range, when it covers one whole placeholder.
fn placeholder_at(text: &str, range: &lsp::Range) -> Option<String> {
if range.start.line != range.end.line {
return None;
}
let line = text.split_inclusive('\n').nth(range.start.line as usize)?;
let line = line.trim_end_matches(['\n', '\r']);
let start = utf16_to_byte(line, range.start.character)?.min(line.len());
// The parser's scalar range ends one past the line (its newline), so the end clamps.
let end = utf16_to_byte(line, range.end.character).unwrap_or(line.len());
if end < start {
return None;
}
let inner = line[start..end].strip_prefix('@')?.strip_suffix('@')?;
(!inner.is_empty() && inner.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_')))
.then(|| inner.to_owned())
}
/// UTF-16 column → byte offset within one line, `None` inside a surrogate pair or past the line.
fn utf16_to_byte(line: &str, col: u32) -> Option<usize> {
let col = col as usize;
let mut units = 0usize;
for (byte, c) in line.char_indices() {
if units == col {
return Some(byte);
}
units += c.len_utf16();
if units > col {
return None;
}
}
(units == col).then_some(line.len())
}
#[cfg(test)]
mod tests {
use super::*;
use lsp_types::{Position, Range};
fn at(line: u32, from: u32, to: u32) -> Range {
Range { start: Position::new(line, from), end: Position::new(line, to) }
}
fn across(from: (u32, u32), to: (u32, u32)) -> Range {
Range { start: Position::new(from.0, from.1), end: Position::new(to.0, to.1) }
}
fn diagnostic(range: Range) -> lsp::Diagnostic {
lsp::Diagnostic { range, message: RESERVED_AT.to_owned(), ..Default::default() }
}
#[test]
fn a_maven_placeholder_placeholder_is_a_false_positive() {
let text = "spring:\n profiles:\n active: @profileActive@\n";
assert!(false_positive(text, &diagnostic(at(2, 12, 27))));
// The parser ends the scalar's range one past the line (its newline): still caught.
assert!(false_positive(text, &diagnostic(at(2, 12, 28))));
// Columns also decode on a line with non-ASCII text before the scalar.
let text = "name: 项目\nvalue: @profileActive@\n";
assert!(false_positive(text, &diagnostic(at(1, 7, 22))));
}
#[test]
fn other_reserved_character_errors_and_shapes_still_show() {
let text = "active: @profileActive@\n";
// Not the parser's message (a backtick, a different wording).
assert!(!false_positive(
text,
&lsp::Diagnostic {
message: "Plain value cannot start with reserved character `".to_owned(),
..diagnostic(at(0, 8, 11))
}
));
// The error's range is stale and no longer covers a placeholder.
assert!(!false_positive(text, &diagnostic(at(0, 0, 10))));
// A single `@`, an unpaired one or a name with spaces is no placeholder.
assert!(!false_positive("active: @\n", &diagnostic(at(0, 8, 9))));
assert!(!false_positive("active: @profile\n", &diagnostic(at(0, 8, 16))));
assert!(!false_positive("active: @pro file@\n", &diagnostic(at(0, 8, 18))));
// A range crossing lines is kept.
assert!(!false_positive("a: @x@\nb: y\n", &diagnostic(across((0, 3), (1, 0)))));
}
#[test]
fn utf16_columns_decode_multi_byte_and_surrogate_pairs() {
// "é" is one UTF-16 unit; "😀" is two, and a column inside it is out of range.
let line = "é😀@token@";
assert_eq!(utf16_to_byte(line, 0), Some(0));
assert_eq!(utf16_to_byte(line, 1), Some(2));
assert_eq!(utf16_to_byte(line, 2), None);
assert_eq!(utf16_to_byte(line, 3), Some(6));
assert_eq!(utf16_to_byte(line, 4), Some(7));
assert_eq!(utf16_to_byte(line, 10), Some(line.len()));
}
}
+30
Переглянути файл
@@ -2568,6 +2568,35 @@ async fn configuration_answer_resyncs_open_documents_of_opted_in_servers() {
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
}
#[tokio::test(flavor = "multi_thread")]
async fn eslint_configuration_includes_workspace_folder() {
let h = harness_configured("mock", "mk", &[("eslint", incremental_caps()), ("mock", incremental_caps())], |cfg| {
if cfg.name == "eslint" {
cfg.settings = Some(json!({ "workingDirectory": { "mode": "auto" } }));
}
});
h.open("a.mk", "x");
h.wait_status("eslint", ServerStatus::Ready).await;
h.wait_status("mock", ServerStatus::Ready).await;
let items = json!({ "items": [{ "section": "" }] });
let eslint: Value =
h.launcher.state("eslint").peer().request("workspace/configuration", items.clone(), None).await.unwrap();
assert_eq!(
eslint,
json!([{
"flag": true,
"nested": { "deep": 1 },
"workingDirectory": { "mode": "auto" },
"workspaceFolder": {
"uri": uri_of(&h.root),
"name": h.root.file_name().unwrap().to_string_lossy(),
},
}])
);
let other: Value = h.launcher.state("mock").peer().request("workspace/configuration", items, None).await.unwrap();
assert_eq!(other, json!([{ "flag": true, "nested": { "deep": 1 } }]));
}
#[tokio::test(flavor = "multi_thread")]
async fn settings_changes_reach_servers_without_restarts() {
let h = harness(&[("mock", incremental_caps()), ("extra", incremental_caps())]);
@@ -3654,6 +3683,7 @@ async fn a_framework_server_serves_files_spelt_differently_from_the_project() {
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)]
+3
Переглянути файл
@@ -250,6 +250,9 @@ pub struct DocumentTextChange {
#[serde(rename_all = "camelCase")]
pub struct DocumentChanged {
pub path: String,
/// The open project `path` is relative to, set when the event is handed to a plugin
/// (the editor posts the absolute path and `null`).
pub project: Option<String>,
pub base_version: u64,
pub version: u64,
pub changes: Vec<DocumentTextChange>,
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
c10d6f373bd3a701e201350d0272a211da72b23cef010144760db5bae44e2c11
ada68dfdf2875668eff1765ec22678315f18ac6f1364c5f7eda742cb58dc3c60
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
cd7a14b6d4464a559c197ba7fcba30fb045a8927c074fd0c310bec6039af0e0f
2279ae4f79c565c4cd59d9191f394c4d7d5b23ef955f1bd30c2e5396d608e46c
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
017cb719d8c3a226cb6178d75da7ae0396b2d78799658ef560f729e8e06f36e3
77be736c11c39de3a1b021a5e66e905c76e2d32352d889d6bcc9315607c54271
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
93a9660a0941f2f57d11ea7ae331bd6d209ddcb134729ee88ec2fd96e978e631
304690bf13cba5d262d54d709d6f18c627880954f0140919118aea0439fbaaf3
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
6a0008339af0935c7c0128d23bf3e885a642c335ad57097cffb3f000766aba33
b24767627e7445ec093cc79cd6c18844e4dcdf123c6b04c24bc37f109c5cdb0f
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
09369df431bb6922463a242484eb82325ce8af287654af97a99eefb3884115a5
0fa52a91772ceb3d45307db4f2561c132df4b966d15f7f9ce177b7a373f7163d
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
897898835f2f42763da34dad29b8f926b230b33f506830e4118e6c5914720bd4
34ea07edc731ab28748b99c398f7e1ee4d41aa22c0760d57027adad40759292f
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
b56b918d1ff51c902dc956a7da944163194fcc93ba5bcf8baafa44fc2b6b039b
470a54d825e84e8ec0418a244c1fc46426c02f299f4a456ff4cc83fa604d08a0
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
ec2f6463d1ce5d70ad7331ae51bca3c8205b55f1f9e5abfe2218d53be2b61437
20a4f662437478b20e5a80aa30afe20b155001f94c2934843ab11b69192833d4
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
8a25727e09b96b35bc90f906215e13d29697b3792ed81f7f80024299e8b23d44
c118a6562e0398e7f0deb64abc9913dd14acec74869d5c04c452923a81455463
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
33d331d6ab59aa44f9884504ecc77a474e99c7223253735983c327bee6e75984
194fa719b8c96ca23f2da73d2d7225c4805b5c48af67b1efff8e76852f0a6a1c
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
b804f22b06f924aebce86f8bc2c24b5306913f2d2a4a0167af10ce86c8f606db
3db661dd4d45a242b79caf642510d71841ba9f09b3b5eaa1854eabe9fcf6292e
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
27e24e96578471e51dace84968daa6ee189aae0d63d27f3054bf4f3a0841fe0c
196769808ae37ede0a7564f42cae087a18f756b3cd31acb7d99470f1bfd70ea6
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
283320b057d39decafce4f86e09ace4df46ef2f31524b6cac0af22bd62795b0c
dcd05de6c207f4594d347ad3dc44089204353dc898e53873f437e3db1928d629
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
dff4f3571bf72eedfbe2e0e2d6b8908e703e890639fb1b854eb4f35226ddbc98
ece50a864d5a85263cb30eb39dceae90fe174336904e9208ae5c9d5da5cbb036
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
f5d7f62056547beffaadf68a04e8393ee29d73d57501d9f8bb39e902e9d9bf61
a2854d3c357d976b5ee1bf7b31fa541a55581102d37ec85ea719d4fdedd962cb
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
8ea7d2a041efe6bcabe8f9bb58b216fe583a7ad39207f0f10b4bf423facc56e7
dbebe5cfa79092169689d43945e4d71e1a61303ce88f6b4f02216ab69083b955
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
3b5b541b94b674762d6c0494bb5e26bbc871460767015a669ecd2771dc063b8a
993b0f11e8cae470b0529fcfcbe9a520c855069ef63f242da3b26a3da2574d5d
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
64411ddd70ae2906710d03c90add26727aa319db38c5bd23971eb442943154c5
d803928d82cbb2991b3f0c53b73dbe2da625b7b2ce25050706b6da09687f2873
Loaded 100 of 507 files, more files were not shown because too many files have changed in this diff. Show more