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

..
Автор SHA1 Повідомлення Дата
l0ng-ai 69633262cf feat(database): SQL resolution scopes
Settings › Languages & Frameworks › SQL Resolution Scopes maps folders
and files of the project to a data source and schema (saved in the
project settings as database.resolutionScopes). SQL files there resolve
against that data source: completion, inspections, navigation and the
console toolbar use it unless another data source is picked in the
toolbar. The deepest folder or file row wins; the Project row applies
everywhere else, and rows whose data source is gone are skipped.

Contributed settings pages can now start on the project scope
(defaultScope), which this page does.

Part of #2457
2026-11-16 10:38:40 +08:00
l0ng-ai a5306bade3 feat(database): show query results in the editor under their statements (#3635)
The database console toolbar gets an In-Editor Results toggle (also the db.toggleInEditorResults action, saved as database.inEditorResults). While it is on, each result set of a run shows in the editor under the statement that produced it, with the result tab grid, toolbar, paging, editing and export, and a close button instead of Pin. Running a statement again replaces its result; deleting the statement drops it. Results follow edits of the text, keep their place when the console is reopened and can be resized by dragging their bottom edge. With the toggle off, results go to the Services view as before.

Closes #2956
2026-11-16 10:30:55 +08:00
itcodesтаsliencio aa8822d9a3 feat(debugger): attach to a running Unity Editor (#2919)
Unity projects get a debug-only "Unity Editor" run configuration, selected by default. Debug opens a picker of local Unity Editor processes with the current project first; Run > Attach to Unity Process is also available. The tool installer fetches the pinned Unity Debugger 3.0.1 adapter with SHA-256 verification, and the session reports ready once the Mono runtime is up. A missing Mono executable on macOS and Linux is reported in the picker.

Refs #1436

Co-authored-by: sliencio <[email protected]>
2026-11-16 10:16:50 +08:00
l0ng-ai 5fca9c9ed0 docs(readme): rename the WeChat group QR image so the new code shows up 2026-11-16 10:11:00 +08:00
Gabriel Gondim 83805734bf feat(notifications): system notifications for balloons while OpenIDEA is in the background (#3606)
Settings › Appearance & Behavior › Notifications › Enable system notifications (global, on by default): a balloon shown while no OpenIDEA window is focused also goes to the OS notification centre with the same title and text, in the UI language; clicking it focuses the window that raised it. Agents emit an Attention event (finished / needs input / failed, de-duplicated) that raises the usual in-IDE notification, so they reach the OS through the same path. Adds tauri-plugin-notification.

Closes #3531

Co-authored-by: GGVidal <[email protected]>
2026-11-16 10:09:54 +08:00
l0ng-ai 0b3d1d67d9 docs(readme): update the WeChat group QR code 2026-11-16 10:08:39 +08:00
l0ng-ai 53a26b95a4 feat(build): read Eclipse projects without a build tool (#3630)
Eclipse projects without Maven or Gradle: .classpath source folders become Source / Test roots and its output folder is excluded; builds use the .classpath libraries and the web content folder (WST component or a conventional folder holding WEB-INF/web.xml) as the Web facet when none is configured; a web project with no artifacts gets <name>:war exploded for Build Artifacts and Tomcat.

Part of #3571
2026-11-16 10:02:16 +08:00
l0ng-ai efa4fb3b43 feat(build): Build Artifacts and Tomcat deployment for projects without a build tool (#3629)
Build Artifacts on a Java project without Maven or Gradle compiles the production classes with javac and lays out each Project Structure artifact: exploded WAR (web root, WEB-INF/classes, WEB-INF/lib), WAR packed from it, or JAR with a manifest (Main-Class, Class-Path) and its libraries next to it. Layouts are rebuilt from scratch and refuse an output folder holding their inputs. The WAR artifacts are offered to Tomcat run configurations; Build before launch packs the WAR in the IDE and records it for deployment.

Part of #3571, closes #2875
2026-11-16 09:54:52 +08:00
l0ng-ai 6df0087038 feat(build): build Java projects without a build tool from their Project Structure (#3627)
Build Project / Rebuild Project on a Java project without Maven or Gradle now compiles with javac from the Project Structure: source roots to <compiler output>/production/<module> (out by default) against the project libraries, module library dependencies and the Web facet's WEB-INF/lib; resources copied next to the classes; tests to the test output with the production classes. JDK: module or project SDK, else an installed JDK for the language level (--release from JDK 9, -source/-target before). Rebuild cleans first. BuildStep can carry in-IDE actions (clean, copy resources); BuildSystem gains javac.

Part of #3571
2026-11-16 09:47:30 +08:00
l0ng-ai bedd9d2fc9 feat(appearance): scopes and file colors for the project view and editor tabs (#3624)
Settings › Appearance & Behavior gets Scopes (named file sets as file:pattern expressions with ||, && and !, optionally limited to a module) and File Colors (a background colour per scope, first match wins, in the project view and on editor tabs; on by default with Tests green and Non-Project Files yellow). The project view's context menu gets File Color for a file or folder, kept as a scope of that path first in the project's File Colors, with Clear File Color.

Closes #3183
2026-11-16 09:36:14 +08:00
Vadim LazukтаInf1mum 696abb08d8 feat(whats-new): show the release notes in the UI language when the update manifest has them (#3567)
The update manifest can carry translated notes as notes.<lang> (for example notes.zh-CN). app_release_notes returns every language it finds, keyed by base language code. What's New shows the UI language's notes and falls back to English. Notes recorded at install stay English and are replaced by the manifest's translation when one exists.

Refs #3525

Co-authored-by: Inf1mum <[email protected]>
2026-11-16 09:34:42 +08:00
l0ng-ai f99ae11c01 feat(release): Chinese update notes from a 中文 section of the release (#3622)
The update manifest's notes come from the release body. A "## 中文" section added at the end of the draft before publishing is now published as notes.zh-CN, and the English notes leave it out. HTML comments, such as the generated-notes marker, are dropped from both.

Refs #3525
2026-11-16 09:28:50 +08:00
Gabriel Gondim b0fbc5a76c feat(mcp): run HTTP Client requests from .http files as built-in tools (#3609)
Adds two built-in MCP tools on top of ide_http. http_list_requests lists the requests in a project .http / .rest file (read-only). http_run_request runs one by index with an optional environment. It needs a trusted project and asks first; the confirmation shows the resolved URL and header names, not their values. The result has status, timing and a body truncated to 8 KiB. Request headers and body are not returned, and URLs in transport errors are redacted. The run is added to the HTTP history.

Refs #3390

Co-authored-by: GGVidal <[email protected]>
2026-11-16 09:26:11 +08:00
l0ng-ai 273564687e ci: split E2E into two parallel shards (#3620)
The E2E job reached its 30-minute limit before finishing (453 of 491 tests, none failed), so whole runs were cancelled. Two Playwright shards (about 250 tests each) run in parallel, each with its own report artifact.

Fixes #3605
2026-11-16 09:23:54 +08:00
l0ng-ai 5436b7202d feat(vcs): show every file of a change in one scrollable diff (#3617)
The diff viewer's settings menu gets Show All Files in One Diff View (off by default). With it on, a diff of a file of a change opens one Combined Changes Diff tab: a block per file under a sticky header, each diff sized to its content and loaded as it nears the viewport, with collapse, open-in-own-tab, file navigation, a shared side-by-side/unified switch and a way back to one tab per file. Blocks reuse DiffEditor in a new fit mode.

Closes #3375
2026-11-16 09:12:11 +08:00
l0ng-ai 9fdb067ec5 feat(vcs): Git staging area mode for the Commit tool window (#3615)
Settings › Version Control › Git › Enable staging area (off by default, non-modal commit interface only) makes the Commit tool window work on the Git index: Staged / Unstaged / Unversioned Files without change lists or inclusion checkboxes, a Stage or Unstage button on each row and group, and a commit of exactly what is staged; with nothing staged, Commit All commits every tracked change. The inclusion is derived from the status, so the commit pipeline is unchanged; the diff's per-block checkboxes are off in this mode.

Closes #2513
2026-11-16 09:01:45 +08:00
Deng Liuтаdengliu c8112f9010 fix(index): prevent Rayon/RwLock deadlock between streaming scans and queries (#3613)
Searching files, folders or symbols while a streaming scan indexed a project of more than 2,048 files could freeze the app for good. Queries hold IndexData::read while scanning on the global Rayon pool; the scan parsed on that same pool, took IndexData::read inside parse_found and published (IndexData::write, writer-preferring) mid-pass, so every worker could block on the lock or on the bounded channel while the query waited for a worker.

- parse_found no longer locks: the previous content hash is captured during classification, and unchanged-content metadata is refreshed inside publish.
- Background indexing and snapshot hydration run on a dedicated INDEX_POOL.
- find_files, find_dirs and find_symbols are async commands on the blocking pool, off the main thread.

Adds a test with concurrent queries across a 4,600-file scan and an unchanged-content rescan.

Co-authored-by: dengliu <[email protected]>
2026-11-16 08:42:32 +08:00
l0ng-ai 0d376cae44 fix(editor): choosers focus their rows, not the pin button, when they open (#3614)
The list popup behind Go to Declaration and the other choosers gave the initial focus to the header's pin button, so arrow keys didn't move through the rows and Enter pinned the results. List takes an autoFocus prop marking it as the popup's initial focus; the list popup sets it. Other popups with a List and header buttons already focus their search field or list.
2026-11-16 08:32:14 +08:00
NealimeKennaтаNealimeKenna b5c86bc064 feat(agents): link symbols named in inline code of agent replies (#3611)
Inline code in an agent reply that names a symbol (FooView, load(), has_header, Config.load, lib.rs::has_header, a.ts#load) now opens its definition, as file paths already did. Keywords, literals and text with spaces or shell syntax are never looked up. Names are looked up once a reply's text has settled and the spans are on screen, in one request through the new find_symbols_named command (exact matches inside the task's project, one walk over the index), and cached per name and folder. A task in a worktree resolves to the same file under its own folder. With several definitions, a file named in the same reply wins, then the task's folder; otherwise clicking opens Go to Declaration's chooser via the new optional EditorService.chooseDeclaration.

Closes #3585

Co-authored-by: NealimeKenna <[email protected]>
2026-11-16 08:29:51 +08:00
Deng Liuтаdengliu 78e169f820 fix(agents): scale Markdown list gutter in em so zoomed list markers don't clip (#3607)
The list gutter in agent replies was a fixed 20px and markers sat 6px left of it without nowrap, so zoomed-in or two-digit ordered markers (10.) were cut at the row's left edge once content-visibility painted the row clipped, or wrapped under overflow-wrap: anywhere. The indent, marker gap and task-list pull-back are now in em (wider for ordered lists and for lists of 100+ items) and markers don't wrap. Adds an e2e case with zoomed single-, two-digit, bullet and task-list markers in measured rows.

Co-authored-by: dengliu <[email protected]>
2026-11-16 08:25:08 +08:00
SunZhiQiang 601f1ee10a fix(agents): retry a failed provider probe instead of caching it (#3612)
A failed provider probe was remembered like a successful one, so a transient startup failure (the CLI updating itself, a busy machine, an initialize timeout) kept showing on the new-task page. Only a successful probe is cached now; a failed one is retried on the next call. Capabilities seeded from the cache are unchanged, since a failed probe carried only defaults.

Co-authored-by: panda-student <[email protected]>
2026-11-16 08:24:13 +08:00
Sameh Elhawaryтаsamehelhawary ea65b8c074 fix(php): only a RequestFailed error is Phoxite's refusal of a refactoring (#3610)
The Phoxite hierarchy adapter treated every server error except ContentModified as the user-facing refusal of a position, so an internal server error read like the user's mistake. Phoxite refuses with LSP RequestFailed (-32803); only that code now becomes invalid input, and other errors go through rpc_err naming the server. Adds ide_jsonrpc::codes::REQUEST_FAILED; the mock test uses -32803 and covers an internal error.

Co-authored-by: samehelhawary <[email protected]>
2026-11-16 08:23:29 +08:00
Deng Liuтаdengliu 10ddb4aa89 feat(agents): per-tab font zoom in Agent chat (#3602)
Increase/Decrease/Reset Font Size and Ctrl/Cmd+mouse wheel (when enabled) zoom the focused Agent chat tab, New Task tab or docked Agent tool window on its own (-6..+36 px): prose, code, reference chips, tool cards, prompts, the composer, Mermaid diagrams and images scale together, and off-screen virtualized rows are re-measured. Reset Font Size resets only the focused Agent surface. svgSize moves to src/ui, shared by the Markdown viewer and agents.

Co-authored-by: dengliu <[email protected]>
2026-11-16 06:46:13 +08:00
Deng Liuтаdengliu 1259423fdc feat(editor): font zoom changes the active editor by default, with an Active/All editors setting (#3604)
Increase/Decrease Font Size, Reset Font Size and Ctrl/Cmd+mouse wheel apply to the active editor (or Markdown preview) by default. Settings > Editor > General > Mouse Control gets an Active editor / All editors choice beside "Change font size with Ctrl/Command+Mouse Wheel" (editor.general.wheelZoomScope); All editors keeps the behaviour from #2488. Reset Font Size resets the active editor; Reset Font Size in All Editors (editor.resetFontSizeAll) stays in the View menu.

Co-authored-by: dengliu <[email protected]>
2026-11-16 06:44:30 +08:00
Sameh Elhawaryтаsamehelhawary 3fed53ced7 feat(php): Pull Members Up and Push Members Down with Phoxite (#3603)
When a server of the document advertises experimental.phoxite.refactor, Pull Members Up / Push Members Down send Phoxite's phoxite/refactor/hierarchyMembers and phoxite/refactor/hierarchy requests; the existing dialog, Problems Detected step and edit application are reused. A refused position becomes invalid input, as the JDT extension's refusal does. PHP joins the hierarchy refactoring languages in Refactor This.

Co-authored-by: samehelhawary <[email protected]>
2026-11-16 06:42:59 +08:00
Sameh Elhawaryтаsamehelhawary ad236cf1a1 feat(plugins): route a server's client commands to a plugin (serverCommands, API 1.9) (#3597)
A language server's code lens, code action or inlay hint can carry a command it leaves to the client. `[[contributes.serverCommands]]` (API 1.9, needs `lsp:<server>`) routes such a command, when no server of the document lists it in `executeCommandProvider`, to the plugin's own command with the arguments as JSON. The first loaded plugin keeps a claimed server + command; the host logs the conflict once. Routed from lsp_execute_command, lsp_apply_code_action and lsp_execute_code_action; a code action's command is matched against its own server's claims only.

Part of #3542.

Co-authored-by: samehelhawary <[email protected]>
2026-11-16 05:32:06 +08:00
l0ng-ai 3b06fc037d test(index): wait for the snapshot instead of a fixed 150 ms
The warm-start snapshot is written on the worker's next round after a short delay; the test polls for it instead of sleeping 150 ms, which loaded CI runners didn't always cover.
2026-11-16 05:21:23 +08:00
l0ng-ai 6d70458e22 fix(rust): colour self as a keyword (#3600)
rust-analyzer's selfKeyword token and @lezer/rust's self tag were painted with Python's self-parameter colour; both now take the keyword colour, as RustRover colours the self parameter by default.
2026-11-16 05:11:06 +08:00
l0ng-ai bbd7c36c40 feat(hierarchy): pin Hierarchy tabs; a new hierarchy replaces the selected unpinned one (#3599)
Call and type hierarchies open in content tabs. A new hierarchy takes the place of the selected tab unless it is pinned, then it opens in its own tab. Tabs are pinned from the shared content tab menu or the pin in place of the close button; a tab shown again keeps its tree and expanded nodes.
2026-11-16 05:09:20 +08:00
l0ng-ai e586923308 test: fix five Windows-only test failures (#3596)
jdtls handle with the jar's portable path; plugin fuel test with headroom for Windows activation and a per-step workload so the refill is still required; cpuprofile test with a platform absolute path; bare python as the saved command on Windows; worktree checkout compared with git's path.
2026-11-16 04:39:58 +08:00
l0ng-ai 2ddc849b88 fix(run): runs started together get their own tabs (#3595)
Rerun Failed Tests for several Go packages and compound configurations start runs concurrently. Each run picked a finished tab before awaiting the editor save and took it only afterwards, so two runs could pick the same tab: one replaced the other and its process never started. A tab a starting run is about to take, or was asked to reuse, is now held until it is taken.

Also fixes the agent model e2e helper: a model row's name now includes its Configure button, so the option is matched by its leading name.
2026-11-16 04:26:13 +08:00
224 змінених файлів з 9331 додано та 598 видалено

No files matched your search

Бінарний файл не відображається.

Після

Ширина:  |  Висота:  |  Розмір: 160 KiB

Бінарний файл не відображається.

До

Ширина:  |  Висота:  |  Розмір: 86 KiB

+7 -3
Переглянути файл
@@ -208,11 +208,15 @@ jobs:
- run: pnpm build
e2e:
name: E2E
name: E2E (${{ matrix.shard }}/2)
needs: changes
if: needs.changes.outputs.frontend == 'true'
timeout-minutes: 30
runs-on: ubuntu-24.04
strategy:
fail-fast: false
matrix:
shard: [1, 2]
# Browsers and their system libraries are preinstalled; keep the tag in step with @playwright/test.
container: mcr.microsoft.com/playwright:v1.64.1-noble
steps:
@@ -222,12 +226,12 @@ jobs:
- uses: actions/setup-node@v5
with: { node-version: 22, cache: pnpm }
- run: pnpm install --frozen-lockfile
- run: pnpm e2e
- run: pnpm e2e --shard=${{ matrix.shard }}/2
env:
HOME: /root
- uses: actions/upload-artifact@v6
if: failure()
with:
name: playwright-report
name: playwright-report-${{ matrix.shard }}
path: playwright-report/
retention-days: 7
+29 -9
Переглянути файл
@@ -262,26 +262,46 @@ jobs:
}
// The update's notes: the release body without its Download section. That
// section only matters on the release page, and What's new follows it.
// A translated section, "## 中文" added at the end of the draft before it is
// published (it runs to the next heading of its level, or the end), becomes
// `notes.zh-CN`: What's new shows it in that UI language and falls back to
// `notes`, the English rest of the body. HTML comments are dropped.
const { data: release } = await github.rest.repos.getRelease({ owner, repo, release_id });
const withoutDownloadSection = (body) => {
const kept = [];
const languages = { "中文": "zh-CN" };
const notesByLanguage = (body) => {
const parts = { "": [] };
let lang = "";
let langLevel = 0;
let skip = 0;
for (const line of body.split(/\r?\n/)) {
for (const line of body.replace(/<!--[\s\S]*?-->/g, "").split(/\r?\n/)) {
const heading = /^(#{1,6})\s+(.*)$/.exec(line);
if (heading) {
const level = heading[1].length;
if (!skip && level <= 3 && /^download$/i.test(heading[2].trim())) {
const title = heading[2].trim();
if (skip && level <= skip) skip = 0;
if (lang && level <= langLevel) lang = "";
if (!skip && level <= 3 && /^download$/i.test(title)) {
skip = level;
continue;
}
if (skip && level <= skip) skip = 0;
if (!skip && !lang && level <= 2 && languages[title]) {
lang = languages[title];
langLevel = level;
parts[lang] ??= [];
continue;
}
}
if (!skip) kept.push(line);
if (!skip) parts[lang].push(line);
}
return kept.join("\n").trim();
return Object.fromEntries(Object.entries(parts).map(([key, lines]) => [key, lines.join("\n").trim()]));
};
const { "": notes, ...translated } = notesByLanguage(String(release.body ?? ""));
const translations = Object.fromEntries(
Object.entries(translated).filter(([, text]) => text).map(([lang, text]) => [`notes.${lang}`, text]),
);
const manifest = {
version: tag.replace(/^v/, ""), notes, ...translations, pub_date: new Date().toISOString(), platforms,
};
const notes = withoutDownloadSection(String(release.body ?? ""));
const manifest = { version: tag.replace(/^v/, ""), notes, pub_date: new Date().toISOString(), platforms };
const old = assets.find((a) => a.name === "latest.json");
if (old) await github.rest.repos.deleteReleaseAsset({ owner, repo, asset_id: old.id });
await github.rest.repos.uploadReleaseAsset({
Створено
+131 -6
Переглянути файл
@@ -199,7 +199,7 @@ dependencies = [
"wayland-backend",
"wayland-client",
"wayland-protocols",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -5722,6 +5722,20 @@ dependencies = [
"serde_repr",
]
[[package]]
name = "mac-notification-sys"
version = "0.6.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fd604973958ddcc11b561193c0fb96ba146506ef2f231ef2e7c35fd2cbc9beca"
dependencies = [
"cc",
"log",
"objc2 0.6.5",
"objc2-foundation 0.3.2",
"time",
"uuid",
]
[[package]]
name = "mach2"
version = "0.6.0"
@@ -5994,6 +6008,20 @@ dependencies = [
"windows-sys 0.60.2",
]
[[package]]
name = "notify-rust"
version = "4.19.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57da5b5d3b7809bf71858da5a2818c3404ca4688c02c8abecdda0fcdec235df3"
dependencies = [
"futures-lite",
"log",
"mac-notification-sys",
"serde",
"tauri-winrt-notification",
"zbus 6.3.0",
]
[[package]]
name = "notify-types"
version = "2.1.0"
@@ -6666,6 +6694,7 @@ dependencies = [
"tauri-build",
"tauri-plugin-dialog",
"tauri-plugin-mcp-bridge",
"tauri-plugin-notification",
"tauri-plugin-opener",
"tauri-plugin-single-instance",
"tauri-plugin-updater",
@@ -8153,7 +8182,7 @@ dependencies = [
"once_cell",
"serde",
"sha2 0.11.1",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -9429,6 +9458,26 @@ dependencies = [
"windows-core",
]
[[package]]
name = "tauri-plugin-notification"
version = "2.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14a226bfb8189ec4ab2c1936e66330ad06c44d9f6c54a674338208491dee177f"
dependencies = [
"log",
"notify-rust",
"rand 0.10.3",
"serde",
"serde_json",
"serde_repr",
"tauri",
"tauri-plugin",
"thiserror 2.0.21",
"time",
"url",
"zbus 5.19.0",
]
[[package]]
name = "tauri-plugin-opener"
version = "2.7.2"
@@ -9448,7 +9497,7 @@ dependencies = [
"thiserror 2.0.21",
"url",
"windows",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -9464,7 +9513,7 @@ dependencies = [
"tokio",
"tracing",
"windows-sys 0.61.2",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -9647,6 +9696,17 @@ dependencies = [
"toml 1.1.8+spec-1.1.0",
]
[[package]]
name = "tauri-winrt-notification"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f37a6c354fd28fc9e322ed9bd47e3959576dad28c9d58ea1cf888cce1c7ccb36"
dependencies = [
"thiserror 2.0.21",
"windows",
"windows-version",
]
[[package]]
name = "tempfile"
version = "3.27.0"
@@ -12137,11 +12197,38 @@ dependencies = [
"uuid",
"windows-sys 0.61.2",
"winnow 1.0.4",
"zbus_macros",
"zbus_macros 5.19.0",
"zbus_names",
"zvariant",
]
[[package]]
name = "zbus"
version = "6.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6b4aae740b23927ceabed962431abab2cdefb9f7f885e5bbab062da09bf580e4"
dependencies = [
"async-trait",
"bitflags 2.13.2",
"endi",
"futures-core",
"hex",
"libc",
"ordered-stream",
"rustix",
"serde",
"serde_repr",
"socket2",
"uds_windows",
"uuid",
"windows-sys 0.61.2",
"winnow 1.0.4",
"zbus_macros 6.3.0",
"zbus_utils",
"zcheapstr",
"zruntime",
]
[[package]]
name = "zbus-secret-service-keyring-store"
version = "1.0.1"
@@ -12150,7 +12237,7 @@ checksum = "74801d001b9e7729adb4f1825b67b398185fed424749aa3d8bacf70417137d9a"
dependencies = [
"keyring-core",
"secret-service",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -12168,6 +12255,18 @@ dependencies = [
"zvariant_utils",
]
[[package]]
name = "zbus_macros"
version = "6.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "37c9dd4beaf145c16fcb2902862f50da86e54aed13dd368ddf64a1d17e6b8529"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.9",
"zbus_utils",
]
[[package]]
name = "zbus_names"
version = "4.3.5"
@@ -12179,6 +12278,19 @@ dependencies = [
"zvariant",
]
[[package]]
name = "zbus_utils"
version = "6.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "af55e52da295311b368c45bcae221f020e28e97a2420360170ce389218e76ec7"
dependencies = [
"proc-macro2",
"quote",
"serde",
"syn 3.0.9",
"winnow 1.0.4",
]
[[package]]
name = "zcheapstr"
version = "1.1.0"
@@ -12335,6 +12447,19 @@ dependencies = [
"simd-adler32",
]
[[package]]
name = "zruntime"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ce6a55d4f521760475a30f7b96779508fe8c40dc834478709454dd1d5f0ebc72"
dependencies = [
"futures-core",
"futures-io",
"rustix",
"socket2",
"windows-sys 0.61.2",
]
[[package]]
name = "zune-core"
version = "0.5.3"
+1 -1
Переглянути файл
@@ -68,7 +68,7 @@ the [official plugins](plugins/official). The plugin API is still a preview.
- [Discord](https://discord.gg/2Zy4yn7gP) — questions, feedback and release news.
- WeChat group — scan to join:
<img src=".github/assets/wechat-group.png" alt="WeChat group QR code" width="200">
<img src=".github/assets/wechat-group-3.png" alt="WeChat group QR code" width="200">
- Contributing: see [CONTRIBUTING.md](CONTRIBUTING.md) and the [contributor docs](https://openidea.sh/en/contribute/setup).
+1 -1
Переглянути файл
@@ -68,7 +68,7 @@ Eklentileri Ayarlar › Eklentiler (Settings › Plugins) bölümünden kur ya d
- [Discord](https://discord.gg/2Zy4yn7gP): sorular, geri bildirim ve sürüm haberleri.
- WeChat grubu, katılmak için kodu okut:
<img src=".github/assets/wechat-group.png" alt="WeChat grubu QR kodu" width="200">
<img src=".github/assets/wechat-group-3.png" alt="WeChat grubu QR kodu" width="200">
- Katkıda bulunmak için: [CONTRIBUTING.md](CONTRIBUTING.md) ve [katkıcı belgeleri](https://openidea.sh/en/contribute/setup).
+1 -1
Переглянути файл
@@ -66,7 +66,7 @@ WebAssembly 组件运行;主题、图标主题和语言无需编写代码。
- [Discord](https://discord.gg/2Zy4yn7gP):提问、反馈和版本发布消息。
- 微信群,扫码加入:
<img src=".github/assets/wechat-group.png" alt="微信群二维码" width="200">
<img src=".github/assets/wechat-group-3.png" alt="微信群二维码" width="200">
- 参与贡献:参见 [CONTRIBUTING.md](CONTRIBUTING.md) 和[贡献者文档](https://openidea.sh/zh/contribute/setup)。
+39 -3
Переглянути файл
@@ -135,6 +135,8 @@ struct Shared {
/// [`IDLE_RELEASE`], in milliseconds (shorter in tests).
idle_release_ms: AtomicU64,
mcp_servers_hook: RwLock<Option<Arc<McpServersFn>>>,
/// Monotonic id for [`AgentEvent::Attention`] episodes.
attention_seq: AtomicU64,
}
/// What an agent offered in its last session, for the New Task page.
@@ -417,6 +419,7 @@ impl AgentManager {
probes: Mutex::new(HashMap::new()),
idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),
mcp_servers_hook: RwLock::new(None),
attention_seq: AtomicU64::new(0),
});
shared.paths.catalogs.subscribe(&shared);
let mut tasks = HashMap::new();
@@ -1204,7 +1207,10 @@ impl AgentManager {
}
/// What `provider` reports about itself, from `initialize` alone: no session is opened,
/// so no MCP server, hook or sign-in runs. Remembered until `refresh`.
/// so no MCP server, hook or sign-in runs. A successful answer is remembered until
/// `refresh`; a failed one is not, so a transient startup failure (a CLI updating itself,
/// a busy machine) is retried on the next call instead of being shown for the rest of
/// the session.
pub async fn probe(&self, provider: &str, refresh: bool) -> IdeResult<AgentProbe> {
if !refresh && let Some(p) = self.shared.probes.lock().get(provider) {
return Ok(p.clone());
@@ -1266,7 +1272,9 @@ impl AgentManager {
}
Err(e) => probe.error = Some(e),
}
self.shared.probes.lock().insert(spec.id, probe.clone());
if probe.error.is_none() {
self.shared.probes.lock().insert(spec.id, probe.clone());
}
Ok(probe)
}
@@ -1690,6 +1698,28 @@ impl Task {
self.emit_task();
}
fn emit_attention(&self, reason: AgentAttentionReason) {
let n = self.shared.attention_seq.fetch_add(1, Ordering::Relaxed);
let tag = match reason {
AgentAttentionReason::Finished => "finished",
AgentAttentionReason::Input => "input",
AgentAttentionReason::Failed => "failed",
};
self.shared.emit(AgentEvent::Attention {
task: self.id.clone(),
event_id: format!("{}:{tag}:{n}", self.id),
reason,
});
}
/// After NeedsInput + optional auto-approve: notify only when the user must still answer.
fn emit_attention_if_input_pending(&self) {
let waiting = !self.permissions.lock().is_empty() && self.state.lock().task.status == AgentStatus::NeedsInput;
if waiting {
self.emit_attention(AgentAttentionReason::Input);
}
}
fn persist(&self) {
// Held from snapshot to rename, so saves land in order and none follows a delete.
let deleted = self.deleted.lock();
@@ -1792,8 +1822,11 @@ impl Task {
}
match (next, result) {
(Some(queued), _) => prompt = queued.prompt,
(None, Ok(_)) => {
(None, Ok(stop)) => {
self.set_status(AgentStatus::Ready, None);
if stop != "cancelled" {
self.emit_attention(AgentAttentionReason::Finished);
}
return self.release_when_idle();
}
(None, Err(failure)) => return self.fail(failure),
@@ -1864,6 +1897,7 @@ impl Task {
}
None => self.set_status(AgentStatus::Failed, Some(failure.message)),
}
self.emit_attention(AgentAttentionReason::Failed);
}
/// Adds `prompt` to the running turn when the agent takes that; gives it back otherwise.
@@ -2495,6 +2529,7 @@ impl Task {
self.permissions.lock().insert(id, tx);
self.set_status(AgentStatus::NeedsInput, None);
self.approve_pending();
self.emit_attention_if_input_pending();
let answer = rx.recv().ok().flatten();
let answers = answer
@@ -2578,6 +2613,7 @@ impl Task {
});
self.permissions.lock().insert(id, tx);
self.set_status(AgentStatus::NeedsInput, None);
self.emit_attention_if_input_pending();
let reply = rx.recv().ok().flatten();
let (response, chosen) = elicitation::answer(&form, reply.as_deref());
self.settle(entry, chosen);
+15
Переглянути файл
@@ -5,6 +5,15 @@ use serde::{Deserialize, Serialize};
use specta::Type;
use std::collections::BTreeMap;
/// Why a task needs the user's attention (native / in-app notify).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AgentAttentionReason {
Finished,
Input,
Failed,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AgentStatus {
@@ -666,6 +675,12 @@ pub enum AgentEvent {
},
/// The installed or configured agent providers changed.
Providers,
/// The task needs attention once (finished turn, explicit input, or failure).
Attention {
task: String,
event_id: String,
reason: AgentAttentionReason,
},
}
pub use ide_core::settings::{AgentMcpServer, McpTransport};
+208
Переглянути файл
@@ -2474,6 +2474,40 @@ async fn reload_providers_updates_registry_install_clears_stale_probes_and_notif
assert!(probe.error.is_none());
}
/// A probe that fails is not remembered, so the next new-task page tries the agent again
/// instead of showing the same startup failure until the IDE restarts.
#[tokio::test(flavor = "multi_thread")]
async fn a_failed_probe_is_retried_instead_of_remembered() {
let tmp = tempfile::tempdir().unwrap();
let calls = Arc::new(Mutex::new(0usize));
let connector: Connector = {
let calls = calls.clone();
Arc::new(move |_spec, _cwd, _client, _stderr| {
*calls.lock() += 1;
Err(std::io::Error::from(std::io::ErrorKind::NotFound))
})
};
let mgr = AgentManager::with_connector(
AgentPaths {
project_root: tmp.path().to_path_buf(),
store_dir: tmp.path().join("store"),
worktrees_dir: tmp.path().join("worktrees"),
models_file: tmp.path().join("models.json"),
custom_agents_dir: None,
home_dir: None,
env_secrets: None,
catalogs: Arc::default(),
},
tokio::runtime::Handle::current(),
connector,
);
assert!(mgr.probe("claude", false).await.unwrap().error.is_some());
assert!(mgr.probe("claude", false).await.unwrap().error.is_some());
assert_eq!(*calls.lock(), 2, "the second call must start the agent again");
assert!(!mgr.shared.probes.lock().contains_key("claude"));
}
/// A session report that changes the cached provider config notifies subscribers,
/// so the composer re-lists models without waiting for the next task (#1490).
/// Reports that change nothing stay silent.
@@ -3585,3 +3619,177 @@ async fn ephemeral_tasks_deny_write_permissions() {
);
mgr.shutdown();
}
fn attention_reasons(events: &[AgentEvent]) -> Vec<AgentAttentionReason> {
events
.iter()
.filter_map(|e| match e {
AgentEvent::Attention { reason, .. } => Some(*reason),
_ => None,
})
.collect()
}
/// `wait_for(Ready/Failed/…)` can return after status is written but before the
/// following `emit_attention` runs on the agent thread — poll the sink instead.
async fn wait_for_attention(events: &Mutex<Vec<AgentEvent>>, reason: AgentAttentionReason) {
for _ in 0..500 {
if attention_reasons(&events.lock()).contains(&reason) {
return;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
panic!("never saw Attention::{reason:?}: {:?}", *events.lock());
}
#[tokio::test(flavor = "multi_thread")]
async fn attention_finished_not_cancelled() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent.clone());
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
let sink = events.clone();
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
let done = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude".into(),
config: Vec::new(),
isolation: Isolation::Local,
base: None,
})
.await
.unwrap();
wait_for(&mgr, &done.id, AgentStatus::Ready).await;
wait_for_attention(&events, AgentAttentionReason::Finished).await;
events.lock().clear();
let cancelled = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("wait"),
provider: "claude".into(),
config: Vec::new(),
isolation: Isolation::Local,
base: None,
})
.await
.unwrap();
wait_for(&mgr, &cancelled.id, AgentStatus::Running).await;
mgr.cancel(&cancelled.id, None).unwrap();
wait_for(&mgr, &cancelled.id, AgentStatus::Ready).await;
// Give a late Finished emission a chance; cancellation must not produce one.
tokio::time::sleep(Duration::from_millis(50)).await;
assert!(
!attention_reasons(&events.lock()).contains(&AgentAttentionReason::Finished),
"cancelled must not notify finished: {:?}",
*events.lock()
);
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn attention_failed() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent {
request_error: Some((codes::INTERNAL_ERROR, "boom".into())),
auth_on_new: true,
..Default::default()
});
let mgr = manager(tmp.path(), agent);
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
let sink = events.clone();
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("Fix"),
provider: "claude".into(),
config: Vec::new(),
isolation: Isolation::Local,
base: None,
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Failed).await;
wait_for_attention(&events, AgentAttentionReason::Failed).await;
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn attention_input_not_auto_bypass() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent);
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
let sink = events.clone();
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
let asked = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("Fix"),
provider: "claude".into(),
config: Vec::new(),
isolation: Isolation::Local,
base: None,
})
.await
.unwrap();
wait_for(&mgr, &asked.id, AgentStatus::NeedsInput).await;
wait_for_attention(&events, AgentAttentionReason::Input).await;
events.lock().clear();
mgr.cancel(&asked.id, None).unwrap();
wait_for(&mgr, &asked.id, AgentStatus::Ready).await;
let bypassed = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("Fix"),
provider: "cursor".into(),
config: vec![AgentConfigChoice { id: config::CURSOR_APPROVAL.into(), value: "bypass".into() }],
isolation: Isolation::Local,
base: None,
})
.await
.unwrap();
wait_for(&mgr, &bypassed.id, AgentStatus::Ready).await;
tokio::time::sleep(Duration::from_millis(50)).await;
assert!(
!attention_reasons(&events.lock()).contains(&AgentAttentionReason::Input),
"auto-bypass must not notify input: {:?}",
*events.lock()
);
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn attention_not_emitted_on_restore() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent);
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude".into(),
config: Vec::new(),
isolation: Isolation::Local,
base: None,
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
mgr.shutdown();
let restored = manager(tmp.path(), Arc::new(FakeAgent::default()));
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
let sink = events.clone();
let tasks = restored.subscribe(Arc::new(move |e| sink.lock().push(e)));
assert!(tasks.iter().any(|t| t.id == task.id));
tokio::time::sleep(Duration::from_millis(50)).await;
assert!(attention_reasons(&events.lock()).is_empty(), "snapshot restore must not re-notify: {:?}", *events.lock());
restored.shutdown();
}
+54 -1
Переглянути файл
@@ -7,6 +7,7 @@ mod fingerprint;
mod launch_resources;
mod parse;
mod single;
mod structure;
mod up_to_date;
pub use fingerprint::{LaunchFingerprint, launch_fingerprint, menu_fingerprint};
@@ -15,6 +16,10 @@ pub use single::{
SingleFileTarget, compile_file_plan, find_javac, javac_step, module_classpath, single_file_classpath,
single_file_target,
};
pub use structure::{
StructureJdk, StructureRoots, artifact_file, artifact_output, language_release, structure_outputs, structure_plan,
structure_war_plan, structure_web_artifacts,
};
pub use up_to_date::{menu_up_to_date, record_menu_build};
use crate::process::{self, Stream};
@@ -55,6 +60,8 @@ pub enum BuildSystem {
CMake,
#[serde(rename = "dotnet")]
Dotnet,
/// A Java project without a build tool, compiled from its Project Structure.
Javac,
}
/// One command of a build.
@@ -65,6 +72,10 @@ pub struct BuildStep {
pub cwd: PathBuf,
pub env: BTreeMap<String, String>,
format: Format,
/// Folders created before the command runs (a compiler's output).
mkdirs: Vec<PathBuf>,
/// Work done in the IDE instead of a command, with its console title.
action: Option<(structure::Action, String)>,
}
impl BuildStep {
@@ -75,16 +86,26 @@ impl BuildStep {
cwd: cwd.to_path_buf(),
env: BTreeMap::new(),
format,
mkdirs: Vec::new(),
action: None,
}
}
fn action(action: structure::Action, root: &Path) -> Self {
let title = action.display(root);
BuildStep { action: Some((action, title)), ..Self::new("", &[], root, Format::Gradle) }
}
/// A CMake configure/build invocation, parsed as compiler output in the Build view.
pub fn cmake(program: &str, args: Vec<String>, cwd: PathBuf, env: BTreeMap<String, String>) -> Self {
Self { program: program.into(), args, cwd, env, format: Format::Gcc }
Self { program: program.into(), args, cwd, env, format: Format::Gcc, mkdirs: Vec::new(), action: None }
}
/// The command line as echoed in the console.
pub fn display(&self) -> String {
if let Some((_, title)) = &self.action {
return title.clone();
}
let program = Path::new(&self.program).file_name().map_or(self.program.clone(), |n| n.to_string_lossy().into());
std::iter::once(program)
.chain(self.args.iter().map(|a| if a.contains(' ') { format!("\"{a}\"") } else { a.clone() }))
@@ -249,6 +270,8 @@ pub fn plan(
BuildSystem::TypeScript => ts_steps(&dir, kind),
BuildSystem::CMake => cmake_steps(&dir, kind, cmake.and_then(<[_]>::first)),
BuildSystem::Dotnet => dotnet_steps(&dir, kind)?,
// Never detected from a folder: it comes from the Project Structure (`structure_plan`).
BuildSystem::Javac => return Err(IdeError::invalid("no build tool to run")),
};
Ok(BuildPlan { system, title, steps })
}
@@ -650,6 +673,36 @@ pub fn run(
let command = step.display();
on_event(BuildEvent::Step { command: command.clone(), cwd: step.cwd.clone().into() });
on_event(BuildEvent::Progress { message: command.clone(), fraction: None });
if let Some((action, _)) = &step.action {
match action.run(cancel) {
Ok(text) => {
if !text.is_empty() {
on_event(BuildEvent::Output { text: format!("{text}\n"), stderr: false });
}
continue;
}
Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => return Err(e),
Err(e) => {
let m = BuildMessage {
severity: Severity::Error,
text: e.message.clone(),
path: None,
range: None,
code: None,
};
on_event(BuildEvent::Output { text: format!("{}\n", e.message), stderr: true });
on_event(BuildEvent::Message { message: m.clone() });
messages.push(m);
success = false;
break;
}
}
}
for dir in &step.mkdirs {
if let Err(e) = std::fs::create_dir_all(dir) {
tracing::debug!(dir = %dir.display(), %e, "cannot create the build output folder");
}
}
let mut parser = OutputParser::new(step.format);
let mut emit = |raws: Vec<RawMessage>, messages: &mut Vec<BuildMessage>| {
for raw in raws {
+817
Переглянути файл
@@ -0,0 +1,817 @@
//! A Java project without a build tool, built from its Project Structure: `javac` compiles
//! the source roots to the module's output folder against the project libraries and the
//! Web facet's `WEB-INF/lib`, and the resources are copied next to the classes; tests the
//! same way into the test output, which also sees the production classes.
use super::*;
use ide_core::settings::{
ArtifactConfig, ArtifactKind, DependencyScope, ModuleStructureSettings, ProjectStructureSettings,
};
use std::fs;
/// The roots of the project as the IDE resolved them (absolute folders).
#[derive(Clone, Debug, Default)]
pub struct StructureRoots {
pub sources: Vec<PathBuf>,
pub tests: Vec<PathBuf>,
pub resources: Vec<PathBuf>,
pub test_resources: Vec<PathBuf>,
pub excluded: Vec<PathBuf>,
}
/// The JDK compiling the project.
#[derive(Clone, Debug)]
pub struct StructureJdk {
pub home: PathBuf,
pub major: u32,
}
/// Where the project's classes go: `<compiler output>/production/<module>` and
/// `<compiler output>/test/<module>` (`out` by default), unless the module names its own.
pub fn structure_outputs(root: &Path, ps: &ProjectStructureSettings) -> (PathBuf, PathBuf) {
let module = root_module(root, ps);
let name = module_name(root);
let base = resolve_dir(root, &ps.compiler_output).unwrap_or_else(|| root.join("out"));
let main = module
.and_then(|m| resolve_dir(root, &m.compiler_output))
.unwrap_or_else(|| base.join("production").join(&name));
let test = module
.and_then(|m| resolve_dir(root, &m.test_compiler_output))
.unwrap_or_else(|| base.join("test").join(&name));
(main, test)
}
fn module_name(root: &Path) -> String {
root.file_name().map_or_else(|| "project".to_owned(), |n| n.to_string_lossy().into_owned())
}
fn root_module<'a>(root: &Path, ps: &'a ProjectStructureSettings) -> Option<&'a ModuleStructureSettings> {
ps.modules.get(".").or_else(|| ps.module_settings(root, root))
}
fn resolve_dir(root: &Path, value: &str) -> Option<PathBuf> {
let value = value.trim();
(!value.is_empty()).then(|| root.join(value))
}
/// `.java` files below `dir`, not inside an excluded folder or another root of `skip`.
fn java_files(dir: &Path, excluded: &[PathBuf], out: &mut Vec<PathBuf>) {
let Ok(entries) = fs::read_dir(dir) else { return };
let mut entries: Vec<_> = entries.flatten().collect();
entries.sort_by_key(|e| e.file_name());
for e in entries {
let path = e.path();
match e.file_type() {
Ok(t) if t.is_dir() => {
if !excluded.iter().any(|x| path.starts_with(x)) {
java_files(&path, excluded, out);
}
}
Ok(t) if t.is_file() && path.extension().is_some_and(|x| x == "java") => out.push(path),
_ => {}
}
}
}
/// Folders and archives of the libraries a module compiles against, for `scope`.
fn library_entries(root: &Path, ps: &ProjectStructureSettings, test: bool) -> Vec<String> {
let wanted = |scope: DependencyScope| match scope {
DependencyScope::Compile | DependencyScope::Provided => true,
DependencyScope::Test => test,
DependencyScope::Runtime => false,
};
let mut out: Vec<String> = Vec::new();
let mut add = |entry: String| {
if !out.contains(&entry) {
out.push(entry);
}
};
let module_deps = root_module(root, ps).map(|m| m.dependencies.as_slice()).unwrap_or_default();
for lib in &ps.libraries {
// A library a module dependency names takes that dependency's scope.
let scope =
module_deps.iter().find(|d| d.kind == "library" && d.target == lib.name).map_or(lib.scope, |d| d.scope);
if wanted(scope) {
for class in &lib.classes {
add(class_entry(root, class));
}
}
}
for dep in module_deps.iter().filter(|d| d.kind == "library" && wanted(d.scope)) {
if !ps.libraries.iter().any(|l| l.name == dep.target) && !dep.target.trim().is_empty() {
add(class_entry(root, &dep.target));
}
}
for facet in ps.facets.iter().filter(|f| f.kind == "web") {
let lib = web_root(root, facet).join("WEB-INF").join("lib");
if lib.is_dir() {
add(format!("{}{}*", lib.to_string_lossy(), std::path::MAIN_SEPARATOR));
}
}
out
}
/// The web resource folder of a Web facet: its own, else the folder holding `WEB-INF/web.xml`.
fn web_root(root: &Path, facet: &ide_core::settings::FacetConfig) -> PathBuf {
let dir = facet.web_root.trim();
let dir = if dir.is_empty() {
facet.descriptor.trim().replace('\\', "/").strip_suffix("/WEB-INF/web.xml").unwrap_or("").to_owned()
} else {
dir.to_owned()
};
root.join(dir)
}
/// The class archives and folders of a library path (`lib/*.jar` lists the folder's jars).
fn library_files(root: &Path, value: &str) -> Vec<PathBuf> {
let entry = class_entry(root, value);
match entry.strip_suffix('*') {
Some(dir) => {
let mut jars: Vec<PathBuf> = fs::read_dir(dir)
.map(|d| d.flatten().map(|e| e.path()).filter(|p| p.extension().is_some_and(|x| x == "jar")).collect())
.unwrap_or_default();
jars.sort();
jars
}
None => vec![PathBuf::from(entry)],
}
}
/// A classpath entry for a library path: a folder of jars (`lib/*`) stays a wildcard javac expands.
fn class_entry(root: &Path, value: &str) -> String {
let path = root.join(value.trim());
let text = path.to_string_lossy().into_owned();
if text.ends_with("/*.jar") || text.ends_with("\\*.jar") {
return text[..text.len() - 4].to_owned();
}
text
}
fn classpath(entries: &[String]) -> String {
entries.join(if cfg!(windows) { ";" } else { ":" })
}
/// `--release N` from JDK 9 on; older compilers only know `-source` / `-target`.
fn release_args(level: Option<u32>, jdk: Option<&StructureJdk>) -> Vec<String> {
let Some(level) = level else { return Vec::new() };
if jdk.is_none_or(|j| j.major >= 9) {
vec!["--release".into(), level.to_string()]
} else {
vec!["-source".into(), format!("1.{level}"), "-target".into(), format!("1.{level}")]
}
}
/// `"17"`, `"1.8"`, `"JDK_17"` → the release number.
pub fn language_release(level: &str) -> Option<u32> {
let digits = level.trim().trim_start_matches("JDK_").trim_start_matches("jdk").replace('_', ".");
let digits = digits.strip_prefix("1.").unwrap_or(&digits);
digits.split(['.', ' ']).next()?.parse().ok().filter(|n| *n > 0)
}
/// The Build / Rebuild plan of a project without a build tool, or `None` when it has no
/// Java sources under its source roots. `language_level`: the project's, unless the module
/// overrides it. Writes the javac argument files below `cache`.
pub fn structure_plan(
root: &Path,
ps: &ProjectStructureSettings,
roots: &StructureRoots,
jdk: Option<&StructureJdk>,
language_level: &str,
kind: BuildKind,
cache: &Path,
) -> IdeResult<Option<BuildPlan>> {
let mut main_sources = Vec::new();
for dir in &roots.sources {
java_files(dir, &roots.excluded, &mut main_sources);
}
let mut test_sources = Vec::new();
for dir in &roots.tests {
java_files(dir, &roots.excluded, &mut test_sources);
}
if main_sources.is_empty() && test_sources.is_empty() {
return Ok(None);
}
let (main_out, test_out) = structure_outputs(root, ps);
let module = root_module(root, ps);
let level = module
.map(|m| m.language_level.as_str())
.filter(|l| !l.trim().is_empty())
.or(Some(language_level))
.and_then(language_release);
let env: BTreeMap<String, String> = jdk
.map(|j| BTreeMap::from([("JAVA_HOME".to_owned(), j.home.to_string_lossy().into_owned())]))
.unwrap_or_default();
let javac = find_javac(&env);
let args_dir = cache.join("javac");
fs::create_dir_all(&args_dir)
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", args_dir.display())))?;
let mut steps = Vec::new();
if kind == BuildKind::Rebuild {
steps.push(BuildStep::action(Action::Clean(vec![main_out.clone(), test_out.clone()]), root));
}
let main_cp = library_entries(root, ps, false);
let compile = |name: &str, sources: &[PathBuf], out: &Path, cp: &[String]| -> IdeResult<BuildStep> {
let args_file = args_dir.join(format!("{name}.args"));
// One quoted path per line: the sources outgrow a command line quickly.
let text: String = sources
.iter()
.map(|p| format!("\"{}\"\n", p.to_string_lossy().replace('\\', "\\\\").replace('"', "\\\"")))
.collect();
fs::write(&args_file, text)
.map_err(|e| IdeError::internal(format!("cannot write {} ({e})", args_file.display())))?;
let mut step = BuildStep::new(&javac, &[], root, Format::Gradle);
step.args.extend(["-encoding".into(), "UTF-8".into(), "-g".into()]);
step.args.extend(["-d".into(), out.to_string_lossy().into_owned()]);
if !cp.is_empty() {
step.args.extend(["-cp".into(), classpath(cp)]);
}
step.args.extend(release_args(level, jdk));
step.args.push(format!("@{}", args_file.to_string_lossy()));
step.env = env.clone();
step.mkdirs = vec![out.to_path_buf()];
Ok(step)
};
if !main_sources.is_empty() {
steps.push(compile("production", &main_sources, &main_out, &main_cp)?);
}
steps.push(BuildStep::action(
Action::CopyResources {
from: roots.sources.iter().chain(&roots.resources).cloned().collect(),
to: main_out.clone(),
},
root,
));
// Artifacts hold production classes only.
if !test_sources.is_empty() && kind != BuildKind::Artifacts {
let mut test_cp = vec![main_out.to_string_lossy().into_owned()];
test_cp.extend(library_entries(root, ps, true));
steps.push(compile("test", &test_sources, &test_out, &test_cp)?);
steps.push(BuildStep::action(
Action::CopyResources {
from: roots.tests.iter().chain(&roots.test_resources).cloned().collect(),
to: test_out.clone(),
},
root,
));
}
if kind == BuildKind::Artifacts {
if ps.artifacts.is_empty() {
return Err(IdeError::invalid("No artifacts are configured: add one in Project Structure › Artifacts"));
}
for artifact in &ps.artifacts {
steps.extend(artifact_steps(root, ps, artifact, &main_out, None, cache));
}
}
Ok(Some(BuildPlan { system: BuildSystem::Javac, title: module_name(root), steps }))
}
/// Where an artifact goes: its output folder, else `out/artifacts/<name>`.
pub fn artifact_output(root: &Path, artifact: &ArtifactConfig) -> PathBuf {
resolve_dir(root, &artifact.output_directory)
.unwrap_or_else(|| root.join("out").join("artifacts").join(file_name(&artifact.name)))
}
/// An artifact name as a file name (`shop:war exploded` → `shop_war_exploded`).
fn file_name(name: &str) -> String {
name.chars().map(|c| if c.is_alphanumeric() || c == '-' || c == '.' { c } else { '_' }).collect()
}
/// The archive a `jar` / `war` artifact writes (`<output>/<name>.war`), or its folder (exploded).
pub fn artifact_file(root: &Path, artifact: &ArtifactConfig) -> PathBuf {
let out = artifact_output(root, artifact);
let base = artifact.name.split(':').next().filter(|n| !n.trim().is_empty()).unwrap_or(&artifact.name);
match artifact.kind {
ArtifactKind::Jar => out.join(format!("{}.jar", file_name(base))),
ArtifactKind::War => out.join(format!("{}.war", file_name(base))),
ArtifactKind::WarExploded => out,
}
}
/// The steps laying out one artifact from the module output `classes`; `war`: write a
/// WAR there instead of the artifact's own output (an application server's deployment).
fn artifact_steps(
root: &Path,
ps: &ProjectStructureSettings,
artifact: &ArtifactConfig,
classes: &Path,
war: Option<&Path>,
cache: &Path,
) -> Vec<BuildStep> {
let libraries: Vec<PathBuf> = ps
.libraries
.iter()
.filter(|l| artifact.include_libraries.contains(&l.name))
.flat_map(|l| l.classes.iter().flat_map(|c| library_files(root, c)))
.collect();
let facet = ps
.facets
.iter()
.filter(|f| f.kind == "web")
.find(|f| f.module == artifact.module || f.module.is_empty() && artifact.module == ".")
.or_else(|| ps.facets.iter().find(|f| f.kind == "web"));
let staging = cache.join("artifacts").join(file_name(&artifact.name));
let mut steps = Vec::new();
match (artifact.kind, war) {
(ArtifactKind::Jar, None) => {
let out = artifact_output(root, artifact);
let mut manifest = String::from("Manifest-Version: 1.0\r\n");
if !artifact.main_class.trim().is_empty() {
manifest.push_str(&format!("Main-Class: {}\r\n", artifact.main_class.trim()));
}
let names: Vec<String> =
libraries.iter().filter_map(|l| l.file_name()).map(|n| n.to_string_lossy().into_owned()).collect();
if !names.is_empty() {
manifest.push_str(&format!("Class-Path: {}\r\n", names.join(" ")));
}
steps.push(BuildStep::action(
Action::Layout { into: staging.clone(), entries: vec![(classes.to_path_buf(), PathBuf::new())] },
root,
));
// The jar's Class-Path names the libraries next to it.
steps.push(BuildStep::action(
Action::Layout {
into: out.clone(),
entries: libraries.iter().map(|l| (l.clone(), file_of(l))).collect(),
},
root,
));
steps.push(BuildStep::action(
Action::Archive { from: staging, to: artifact_file(root, artifact), manifest: Some(manifest) },
root,
));
}
(kind, war) => {
let exploded = match (kind, war) {
(ArtifactKind::WarExploded, None) => artifact_output(root, artifact),
_ => staging.clone(),
};
let mut entries = Vec::new();
if let Some(facet) = facet {
entries.push((web_root(root, facet), PathBuf::new()));
}
entries.push((classes.to_path_buf(), PathBuf::from("WEB-INF/classes")));
for lib in &libraries {
entries.push((lib.clone(), Path::new("WEB-INF/lib").join(file_of(lib))));
}
steps.push(BuildStep::action(Action::Layout { into: exploded.clone(), entries }, root));
let archive = war
.map(Path::to_path_buf)
.or_else(|| (kind != ArtifactKind::WarExploded).then(|| artifact_file(root, artifact)));
if let Some(to) = archive {
steps.push(BuildStep::action(Action::Archive { from: exploded, to, manifest: None }, root));
}
}
}
steps
}
fn file_of(path: &Path) -> PathBuf {
path.file_name().map(PathBuf::from).unwrap_or_default()
}
/// The WAR artifacts of a project without a build tool: an application server deploys them.
pub fn structure_web_artifacts(ps: &ProjectStructureSettings) -> Vec<&ArtifactConfig> {
ps.artifacts.iter().filter(|a| matches!(a.kind, ArtifactKind::War | ArtifactKind::WarExploded)).collect()
}
/// A build of `artifact` into the WAR `war` (Tomcat's deployment), compiling first.
#[allow(clippy::too_many_arguments)]
pub fn structure_war_plan(
root: &Path,
ps: &ProjectStructureSettings,
roots: &StructureRoots,
jdk: Option<&StructureJdk>,
language_level: &str,
artifact: &ArtifactConfig,
war: &Path,
cache: &Path,
) -> IdeResult<BuildPlan> {
let mut plan = structure_plan(root, ps, roots, jdk, language_level, BuildKind::Build, cache)?
.unwrap_or_else(|| BuildPlan { system: BuildSystem::Javac, title: module_name(root), steps: Vec::new() });
let (main_out, _) = structure_outputs(root, ps);
// Tests are not part of a deployment.
plan.steps.retain(|s| !s.args.iter().any(|a| a.ends_with("test.args")));
plan.steps
.retain(|s| !matches!(&s.action, Some((Action::CopyResources { to, .. }, _)) if !to.starts_with(&main_out)));
plan.steps.extend(artifact_steps(root, ps, artifact, &main_out, Some(war), cache));
plan.title = artifact.name.clone();
Ok(plan)
}
/// Work a build does in the IDE itself rather than through a tool.
#[derive(Clone, Debug, PartialEq)]
pub(crate) enum Action {
/// Deletes these output folders (Rebuild).
Clean(Vec<PathBuf>),
/// Copies the files of these folders that are not Java sources into `to`, keeping their
/// relative paths; files that are already up to date are left alone.
CopyResources { from: Vec<PathBuf>, to: PathBuf },
/// Lays out an artifact in `into`: each folder's content or file goes to its relative
/// place (`""` = the top). What is no longer laid out is removed.
Layout { into: PathBuf, entries: Vec<(PathBuf, PathBuf)> },
/// Zips the folder `from` into the archive `to`, with this manifest first.
Archive { from: PathBuf, to: PathBuf, manifest: Option<String> },
}
impl Action {
pub(crate) fn display(&self, root: &Path) -> String {
let rel = |p: &Path| p.strip_prefix(root).unwrap_or(p).to_string_lossy().into_owned();
match self {
Action::Clean(dirs) => format!("Clean {}", dirs.iter().map(|d| rel(d)).collect::<Vec<_>>().join(", ")),
Action::CopyResources { to, .. } => format!("Copy resources to {}", rel(to)),
Action::Layout { into, .. } => format!("Lay out {}", rel(into)),
Action::Archive { to, .. } => format!("Pack {}", rel(to)),
}
}
/// Runs the action; the text is a summary for the console.
pub(crate) fn run(&self, cancel: &CancellationToken) -> IdeResult<String> {
match self {
Action::Clean(dirs) => {
for dir in dirs.iter().filter(|d| d.exists()) {
fs::remove_dir_all(dir)
.map_err(|e| IdeError::internal(format!("cannot delete {} ({e})", dir.display())))?;
}
Ok(String::new())
}
Action::CopyResources { from, to } => {
let mut copied = 0;
for dir in from {
copied += copy_resources(dir, dir, to, cancel)?;
}
Ok(format!("{copied} resource file(s) copied"))
}
Action::Layout { into, entries } => {
// A fresh layout: files dropped from the sources must not linger in the artifact.
if entries.iter().any(|(from, _)| from.starts_with(into)) {
return Err(IdeError::invalid(format!(
"The artifact output folder {} holds files the artifact is made of",
into.display()
)));
}
if into.exists() {
fs::remove_dir_all(into)
.map_err(|e| IdeError::internal(format!("cannot delete {} ({e})", into.display())))?;
}
let mut copied = 0;
for (from, to) in entries {
let target = into.join(to);
if from.is_dir() {
copied += copy_tree(from, &target, cancel)?;
} else if from.is_file() {
copy_file(from, &target)?;
copied += 1;
}
}
Ok(format!("{copied} file(s) laid out"))
}
Action::Archive { from, to, manifest } => {
archive(from, to, manifest.as_deref(), cancel)?;
Ok(format!("Wrote {}", to.display()))
}
}
}
}
fn copy_file(from: &Path, to: &Path) -> IdeResult<()> {
if let Some(parent) = to.parent() {
fs::create_dir_all(parent)
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
}
fs::copy(from, to).map_err(|e| IdeError::internal(format!("cannot copy {} ({e})", from.display())))?;
Ok(())
}
fn copy_tree(from: &Path, to: &Path, cancel: &CancellationToken) -> IdeResult<usize> {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let Ok(entries) = fs::read_dir(from) else { return Ok(0) };
let mut copied = 0;
for e in entries.flatten() {
let Ok(t) = e.file_type() else { continue };
let target = to.join(e.file_name());
if t.is_dir() {
copied += copy_tree(&e.path(), &target, cancel)?;
} else if t.is_file() {
copy_file(&e.path(), &target)?;
copied += 1;
}
}
Ok(copied)
}
fn archive(from: &Path, to: &Path, manifest: Option<&str>, cancel: &CancellationToken) -> IdeResult<()> {
use std::io::Write;
let err = |e: &dyn std::fmt::Display| IdeError::internal(format!("cannot write {} ({e})", to.display()));
if let Some(parent) = to.parent() {
fs::create_dir_all(parent).map_err(|e| err(&e))?;
}
let mut zip = zip::ZipWriter::new(fs::File::create(to).map_err(|e| err(&e))?);
let options = zip::write::SimpleFileOptions::default();
if let Some(manifest) = manifest {
zip.add_directory("META-INF/", options).map_err(|e| err(&e))?;
zip.start_file("META-INF/MANIFEST.MF", options).map_err(|e| err(&e))?;
zip.write_all(manifest.as_bytes()).map_err(|e| err(&e))?;
}
let mut stack = vec![from.to_path_buf()];
while let Some(dir) = stack.pop() {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let Ok(entries) = fs::read_dir(&dir) else { continue };
let mut entries: Vec<_> = entries.flatten().collect();
entries.sort_by_key(|e| e.file_name());
for e in entries {
let path = e.path();
let name = path.strip_prefix(from).unwrap_or(&path).to_string_lossy().replace('\\', "/");
if manifest.is_some() && name.eq_ignore_ascii_case("META-INF/MANIFEST.MF") {
continue;
}
match e.file_type() {
Ok(t) if t.is_dir() => {
if !(manifest.is_some() && name == "META-INF") {
zip.add_directory(format!("{name}/"), options).map_err(|e| err(&e))?;
}
stack.push(path);
}
Ok(t) if t.is_file() => {
zip.start_file(name, options).map_err(|e| err(&e))?;
let mut file = fs::File::open(&path).map_err(|e| err(&e))?;
std::io::copy(&mut file, &mut zip).map_err(|e| err(&e))?;
}
_ => {}
}
}
}
zip.finish().map_err(|e| err(&e))?;
Ok(())
}
fn copy_resources(base: &Path, dir: &Path, to: &Path, cancel: &CancellationToken) -> IdeResult<usize> {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let Ok(entries) = fs::read_dir(dir) else { return Ok(0) };
let mut copied = 0;
for e in entries.flatten() {
let path = e.path();
let Ok(t) = e.file_type() else { continue };
if t.is_dir() {
// The output folder can sit inside a source root (`src` holding `classes`).
if path != to && !path.starts_with(to) {
copied += copy_resources(base, &path, to, cancel)?;
}
continue;
}
if !t.is_file() || path.extension().is_some_and(|x| x == "java") {
continue;
}
let target = to.join(path.strip_prefix(base).unwrap_or(&path));
let newer =
match (fs::metadata(&path).and_then(|m| m.modified()), fs::metadata(&target).and_then(|m| m.modified())) {
(Ok(source), Ok(existing)) => source > existing,
_ => true,
};
if newer {
if let Some(parent) = target.parent() {
fs::create_dir_all(parent)
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
}
fs::copy(&path, &target)
.map_err(|e| IdeError::internal(format!("cannot copy {} ({e})", path.display())))?;
copied += 1;
}
}
Ok(copied)
}
#[cfg(test)]
mod tests {
use super::*;
use ide_core::settings::{FacetConfig, ModuleDependency, ProjectLibrary};
fn write(path: &Path, text: &str) {
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, text).unwrap();
}
#[test]
fn reads_language_levels() {
assert_eq!(language_release("17"), Some(17));
assert_eq!(language_release("1.8"), Some(8));
assert_eq!(language_release("JDK_11"), Some(11));
assert_eq!(language_release(""), None);
}
#[test]
fn plans_javac_over_source_roots_with_libraries_and_web_lib() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("shop");
write(&root.join("src/com/a/A.java"), "package com.a; class A {}");
write(&root.join("src/com/a/app.properties"), "x=1");
write(&root.join("test/com/a/ATest.java"), "package com.a; class ATest {}");
write(&root.join("WebRoot/WEB-INF/web.xml"), "<web-app/>");
write(&root.join("WebRoot/WEB-INF/lib/x.jar"), "");
let ps = ProjectStructureSettings {
libraries: vec![
ProjectLibrary { name: "tools".into(), classes: vec!["lib/*.jar".into()], ..Default::default() },
ProjectLibrary {
name: "junit".into(),
classes: vec!["junit.jar".into()],
scope: DependencyScope::Test,
..Default::default()
},
],
facets: vec![FacetConfig {
kind: "web".into(),
module: ".".into(),
descriptor: "WebRoot/WEB-INF/web.xml".into(),
web_root: String::new(),
}],
..Default::default()
};
let roots =
StructureRoots { sources: vec![root.join("src")], tests: vec![root.join("test")], ..Default::default() };
let jdk = StructureJdk { home: PathBuf::from("/jdk"), major: 21 };
let plan = structure_plan(&root, &ps, &roots, Some(&jdk), "17", BuildKind::Rebuild, &tmp.path().join("cache"))
.unwrap()
.unwrap();
assert_eq!(plan.system, BuildSystem::Javac);
let shown: Vec<String> = plan.steps.iter().map(BuildStep::display).collect();
assert_eq!(shown[0], "Clean out/production/shop, out/test/shop");
let javac = &plan.steps[1];
let cp = |s: &BuildStep| s.args[s.args.iter().position(|a| a == "-cp").unwrap() + 1].clone();
let sep = if cfg!(windows) { ";" } else { ":" };
let main_cp = cp(javac);
let entries: Vec<&str> = main_cp.split(sep).collect();
assert_eq!(entries.len(), 2, "{main_cp}");
assert!(entries[0].ends_with("lib/*"));
assert!(entries[1].ends_with("WEB-INF/lib/*"));
assert!(javac.args.windows(2).any(|w| w == ["--release", "17"]));
let args = fs::read_to_string(tmp.path().join("cache/javac/production.args")).unwrap();
assert!(args.contains("A.java") && !args.contains("ATest.java"));
assert_eq!(shown[2], "Copy resources to out/production/shop");
let test = &plan.steps[3];
let test_cp = cp(test);
assert!(test_cp.starts_with(&root.join("out/production/shop").to_string_lossy().into_owned()));
assert!(test_cp.contains("junit.jar"));
}
#[test]
fn a_module_dependency_gives_its_library_a_scope_and_jdk_8_gets_source_and_target() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("p");
write(&root.join("src/A.java"), "class A {}");
let mut ps = ProjectStructureSettings {
libraries: vec![ProjectLibrary {
name: "junit".into(),
classes: vec!["junit.jar".into()],
..Default::default()
}],
compiler_output: "build/classes".into(),
..Default::default()
};
ps.modules.insert(
".".into(),
ModuleStructureSettings {
language_level: "1.8".into(),
dependencies: vec![ModuleDependency {
kind: "library".into(),
target: "junit".into(),
scope: DependencyScope::Test,
exported: false,
}],
..Default::default()
},
);
let roots = StructureRoots { sources: vec![root.join("src")], ..Default::default() };
let jdk = StructureJdk { home: PathBuf::from("/jdk8"), major: 8 };
let plan = structure_plan(&root, &ps, &roots, Some(&jdk), "21", BuildKind::Build, &tmp.path().join("c"))
.unwrap()
.unwrap();
let javac = &plan.steps[0];
assert!(!javac.args.iter().any(|a| a == "-cp"), "{:?}", javac.args);
assert!(javac.args.windows(4).any(|w| w == ["-source", "1.8", "-target", "1.8"]));
assert!(javac.args.windows(2).any(|w| w[0] == "-d" && w[1].ends_with("build/classes/production/p")));
}
#[test]
fn no_plan_without_java_sources() {
let tmp = tempfile::tempdir().unwrap();
let roots = StructureRoots { sources: vec![tmp.path().join("src")], ..Default::default() };
let plan =
structure_plan(tmp.path(), &Default::default(), &roots, None, "", BuildKind::Build, &tmp.path().join("c"));
assert!(plan.unwrap().is_none());
}
#[test]
fn copies_resources_but_not_sources_and_skips_up_to_date_files() {
let tmp = tempfile::tempdir().unwrap();
let src = tmp.path().join("src");
write(&src.join("a/A.java"), "class A {}");
write(&src.join("a/x.xml"), "<x/>");
let out = tmp.path().join("out");
let action = Action::CopyResources { from: vec![src], to: out.clone() };
let cancel = CancellationToken::new();
assert_eq!(action.run(&cancel).unwrap(), "1 resource file(s) copied");
assert!(out.join("a/x.xml").is_file() && !out.join("a/A.java").exists());
assert_eq!(action.run(&cancel).unwrap(), "0 resource file(s) copied");
Action::Clean(vec![out.clone()]).run(&cancel).unwrap();
assert!(!out.exists());
}
fn entries(archive: &Path) -> Vec<String> {
let mut zip = zip::ZipArchive::new(fs::File::open(archive).unwrap()).unwrap();
(0..zip.len()).map(|i| zip.by_index(i).unwrap().name().unwrap().into_owned()).collect()
}
fn run_plan(plan: &BuildPlan) {
let cancel = CancellationToken::new();
for step in &plan.steps {
if let Some((action, _)) = &step.action {
action.run(&cancel).unwrap();
}
}
}
#[test]
fn lays_out_war_jar_and_exploded_artifacts() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("shop");
write(&root.join("WebRoot/index.jsp"), "hi");
write(&root.join("WebRoot/WEB-INF/web.xml"), "<web-app/>");
write(&root.join("WebRoot/WEB-INF/lib/inside.jar"), "");
write(&root.join("lib/extra.jar"), "");
let classes = root.join("out/production/shop");
write(&classes.join("com/a/A.class"), "");
let artifact = |name: &str, kind| ArtifactConfig {
name: name.into(),
kind,
module: ".".into(),
include_libraries: vec!["extra".into()],
main_class: "com.a.A".into(),
..Default::default()
};
let ps = ProjectStructureSettings {
libraries: vec![ProjectLibrary {
name: "extra".into(),
classes: vec!["lib/*.jar".into()],
..Default::default()
}],
facets: vec![FacetConfig {
kind: "web".into(),
module: ".".into(),
descriptor: "WebRoot/WEB-INF/web.xml".into(),
web_root: String::new(),
}],
artifacts: vec![
artifact("shop:war", ArtifactKind::War),
artifact("shop:war exploded", ArtifactKind::WarExploded),
artifact("shop:jar", ArtifactKind::Jar),
],
..Default::default()
};
let cache = tmp.path().join("cache");
for a in &ps.artifacts {
let plan = BuildPlan {
system: BuildSystem::Javac,
title: String::new(),
steps: artifact_steps(&root, &ps, a, &classes, None, &cache),
};
run_plan(&plan);
}
let war = entries(&root.join("out/artifacts/shop_war/shop.war"));
for name in [
"index.jsp",
"WEB-INF/web.xml",
"WEB-INF/lib/inside.jar",
"WEB-INF/lib/extra.jar",
"WEB-INF/classes/com/a/A.class",
] {
assert!(war.iter().any(|e| e == name), "{name} in {war:?}");
}
let exploded = root.join("out/artifacts/shop_war_exploded");
assert!(exploded.join("WEB-INF/classes/com/a/A.class").is_file());
assert!(exploded.join("WEB-INF/lib/extra.jar").is_file());
let jar_dir = root.join("out/artifacts/shop_jar");
let jar = entries(&jar_dir.join("shop.jar"));
assert_eq!(jar[..2], ["META-INF/".to_owned(), "META-INF/MANIFEST.MF".to_owned()]);
assert!(jar.iter().any(|e| e == "com/a/A.class"));
assert!(jar_dir.join("extra.jar").is_file());
let mut zip = zip::ZipArchive::new(fs::File::open(jar_dir.join("shop.jar")).unwrap()).unwrap();
let mut manifest = String::new();
std::io::Read::read_to_string(&mut zip.by_name("META-INF/MANIFEST.MF").unwrap(), &mut manifest).unwrap();
assert!(manifest.contains("Main-Class: com.a.A") && manifest.contains("Class-Path: extra.jar"));
}
#[test]
fn never_lays_out_over_its_own_sources() {
let tmp = tempfile::tempdir().unwrap();
let web = tmp.path().join("WebRoot");
write(&web.join("a.jsp"), "");
let action = Action::Layout { into: tmp.path().to_path_buf(), entries: vec![(web.clone(), PathBuf::new())] };
assert!(action.run(&CancellationToken::new()).is_err());
assert!(web.join("a.jsp").is_file());
}
}
+3
Переглянути файл
@@ -12,6 +12,8 @@ use std::collections::BTreeMap;
pub struct EditorGeneralSettings {
/// Change font size with ⌘ + mouse wheel.
pub wheel_zoom: bool,
/// Scope of ⌘ + mouse wheel font zoom: `active` editor | `all` editors.
pub wheel_zoom_scope: String,
pub markdown_image_folder: String,
pub markdown_image_name_pattern: String,
/// Drag-and-drop of selected text inside the editor.
@@ -37,6 +39,7 @@ impl Default for EditorGeneralSettings {
fn default() -> Self {
Self {
wheel_zoom: false,
wheel_zoom_scope: "active".into(),
markdown_image_folder: "assets".into(),
markdown_image_name_pattern: "image-{timestamp}".into(),
drag_and_drop: true,
+58 -1
Переглянути файл
@@ -67,6 +67,12 @@ pub struct Settings {
pub mcp_server: McpServerSettings,
/// Tools › Agents: Command Execution Policy.
pub agent_security: AgentSecuritySettings,
/// Appearance & Behavior › Scopes: named file sets other settings refer to.
pub scopes: Vec<NamedScope>,
/// Appearance & Behavior › File Colors.
pub file_colors: FileColorSettings,
/// Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes.
pub database: DatabaseSettings,
/// Plugin settings (`[contributes.settings]`): plugin id → its values by key.
#[specta(type = BTreeMap<String, BTreeMap<String, specta_typescript::Unknown>>)]
pub plugins: BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
@@ -502,6 +508,9 @@ impl Default for Settings {
agents: AgentSettings::default(),
mcp_server: McpServerSettings::default(),
agent_security: AgentSecuritySettings::default(),
scopes: Vec::new(),
file_colors: FileColorSettings::default(),
database: DatabaseSettings::default(),
plugins: BTreeMap::new(),
}
}
@@ -512,6 +521,47 @@ fn default_keymap() -> &'static str {
if cfg!(target_os = "macos") { "intellij-macos" } else { "intellij-windows" }
}
/// A named set of files: `file:src//*.ts && !file:*.test.ts` (project-relative path patterns
/// joined with `||`, `&&`, `!` and parentheses).
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct NamedScope {
pub name: String,
pub pattern: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct FileColorSettings {
pub enabled: bool,
pub editor_tabs: bool,
pub project_view: bool,
/// Scope → colour; the first scope that holds a file gives its colour.
pub colors: Vec<FileColor>,
}
impl Default for FileColorSettings {
fn default() -> Self {
let color = |scope: &str, color: &str| FileColor { scope: scope.into(), color: color.into() };
Self {
enabled: true,
editor_tabs: true,
project_view: true,
colors: vec![color("Non-Project Files", "yellow"), color("Tests", "green")],
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct FileColor {
/// A built-in scope (`Tests`, `Production`, `Project Files`, `Non-Project Files`) or a
/// `scopes` entry, by name.
pub scope: String,
/// A palette name (`blue`, `green`, `orange`, `rose`, `violet`, `yellow`, `gray`) or `#rrggbb`.
pub color: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct CustomKeymap {
@@ -600,13 +650,20 @@ impl Default for DateFormatSettings {
pub struct NotificationSettings {
pub balloons: bool,
pub sound: bool,
/// Mirror balloon notifications to the OS when no OpenIDEA window is focused.
#[serde(default = "default_true")]
pub system_notifications: bool,
/// Group id → display; groups not listed use their default.
pub groups: BTreeMap<String, NotificationGroupSettings>,
}
fn default_true() -> bool {
true
}
impl Default for NotificationSettings {
fn default() -> Self {
Self { balloons: true, sound: false, groups: BTreeMap::new() }
Self { balloons: true, sound: false, system_notifications: true, groups: BTreeMap::new() }
}
}
+28
Переглянути файл
@@ -69,6 +69,9 @@ pub struct GitSettings {
pub push_dialog_only_protected: bool,
/// Stashes and shelves share one tab.
pub combine_stash_and_shelf: bool,
/// The non-modal Commit tool window works on the index: Staged / Unstaged groups,
/// stage and unstage instead of inclusion checkboxes, and no change lists.
pub staging_area: bool,
}
impl Default for GitSettings {
@@ -90,6 +93,7 @@ impl Default for GitSettings {
show_push_dialog: true,
push_dialog_only_protected: false,
combine_stash_and_shelf: false,
staging_area: false,
}
}
}
@@ -237,6 +241,30 @@ impl Default for LogLevelColors {
}
}
/// Database settings: Query Execution and SQL Resolution Scopes.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct DatabaseSettings {
/// A console's result sets show under the statements that produced them, in the editor,
/// instead of in the Services view's result tabs.
pub in_editor_results: bool,
/// Languages & Frameworks › SQL Resolution Scopes: the data source SQL in a file or folder
/// resolves against (completion, inspections, navigation), most specific path first.
pub resolution_scopes: Vec<SqlResolutionScope>,
}
/// One row of SQL Resolution Scopes.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct SqlResolutionScope {
/// Project-relative file or folder, `/`-separated; empty for the whole project.
pub path: String,
/// Data source id.
pub data_source: String,
/// Schema unqualified names resolve in; empty for the data source's default.
pub schema: String,
}
/// Build, Execution, Deployment › Console.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
+6
Переглянути файл
@@ -120,6 +120,12 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
"stdio",
"Install GDB 14 or newer (apt install gdb, dnf install gdb, brew install gdb)",
),
"unity" => cfg(
"unity-debug",
&[],
"stdio",
"Install Unity Debugger in Settings > Language Servers, or configure the unity-debug tool path",
),
"rdbg" => cfg("rdbg", &["-O", "--port", PORT_PLACEHOLDER, "-c"], "tcp", "gem install debug"),
// A jdtls bundle: the session is started through jdtls and reached via `debugServer`.
"java-debug" => cfg(
+1
Переглянути файл
@@ -12,6 +12,7 @@ use std::path::Path;
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AttachKind {
Unity,
Java,
Node,
Python,
+15
Переглянути файл
@@ -19,6 +19,7 @@ mod jvm_memory;
pub mod kotlin;
pub mod kotlin_lsp;
mod session;
pub mod unity;
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
use connection::{Connection, DapError};
@@ -1121,6 +1122,16 @@ impl DebugManager {
let _ = tokio::time::timeout(INIT_TIMEOUT, initialized.wait_for(|v| *v)).await;
}
if s.adapter == "unity" {
if launch_result.is_none()
&& let Some(launch) = launch.as_mut()
{
launch.await?;
launch_result = Some(());
}
unity::wait_for_threads(s).await?;
}
// A fresh adapter has no breakpoints, so a file with none enabled needs no request; the
// others go out together, as VS Code sends them, instead of one round trip per file.
let (files, idle): (Vec<_>, Vec<_>) = self
@@ -1202,6 +1213,10 @@ impl DebugManager {
if let Some(link) = s.jdwp_link.lock().as_ref() {
link.release();
}
if s.adapter == "unity" {
unity::settle_startup(s).await;
s.emit(ide_core::event::DebugEvent::Initialized);
}
Ok(())
}
+15 -2
Переглянути файл
@@ -17,7 +17,7 @@ use std::process::Stdio;
use std::sync::Arc;
use std::sync::Weak;
use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
use std::time::Duration;
use std::time::{Duration, Instant};
use tokio::io::{AsyncRead, AsyncReadExt};
use tokio::process::Child;
use tokio::sync::{mpsc, watch};
@@ -116,6 +116,7 @@ pub(crate) struct Session {
pub jvm_memory: tokio::sync::Mutex<crate::JvmMemoryState>,
/// Used only by a kotlin-lsp session: see [`Session::kotlin_lsp_quirks`].
pub(crate) quirks: kotlin_lsp::Quirks,
pub(crate) unity_startup_activity: Mutex<Instant>,
}
/// Which threads of the program are suspended: each from its `stopped` event until a
@@ -270,6 +271,7 @@ impl Session {
kotlin_mirror: Mutex::new(None),
jvm_memory: tokio::sync::Mutex::default(),
quirks: kotlin_lsp::Quirks::default(),
unity_startup_activity: Mutex::new(Instant::now()),
}
}
@@ -716,6 +718,15 @@ pub(crate) async fn event_loop(
}
async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut body: Value) {
if s.adapter == "unity"
&& event == "output"
&& body
.get("output")
.and_then(Value::as_str)
.is_some_and(|text| text.starts_with("Loaded assembly:") || text.starts_with("Resolved pending breakpoint"))
{
*s.unity_startup_activity.lock() = Instant::now();
}
if let Some(mirror) = s.kotlin_mirror.lock().as_ref() {
mirror.translate(&mut body);
}
@@ -724,7 +735,9 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
match event {
"initialized" => {
s.initialized.send_replace(true);
s.emit(DebugEvent::Initialized);
if s.adapter != "unity" {
s.emit(DebugEvent::Initialized);
}
}
"stopped" => {
let all = body.get("allThreadsStopped").and_then(Value::as_bool).unwrap_or(false);
+47 -2
Переглянути файл
@@ -158,6 +158,7 @@ struct Script {
/// `launch`, and a `configurationDone` sent while it runs is refused with `notStopped`.
gdb15_starts_at_launch: bool,
launch_after_configuration: bool,
empty_thread_responses: usize,
/// Requests of the adapter's own (js-debug's `setCustomBreakpoints`…) answered with an empty body.
accept: &'static [&'static str],
/// Requests of the adapter's own answered with a body and followed by events.
@@ -198,6 +199,7 @@ impl Default for Script {
close_during_startup: false,
gdb15_starts_at_launch: false,
launch_after_configuration: false,
empty_thread_responses: 0,
accept: &[],
custom: None,
}
@@ -244,6 +246,8 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
let mut held: Vec<Value> = Vec::new();
let mut stopped = false;
let mut running = false;
let mut thread_requests = 0;
let mut unity = false;
macro_rules! send {
($v:expr) => {{
let mut v: Value = $v;
@@ -268,13 +272,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
}
match msg["command"].as_str().unwrap_or_default() {
"initialize" => {
unity = msg["arguments"]["adapterID"] == "unity";
if let Some(delay) = script.delay_initialize {
tokio::time::sleep(delay).await;
}
ok!(
msg,
json!({
"supportsConfigurationDoneRequest": true,
"supportsConfigurationDoneRequest": !unity,
"supportsCompletionsRequest": true,
"supportsTerminateRequest": script.supports_terminate,
"supportsSetVariable": true,
@@ -293,8 +298,15 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
// defers it sends late).
send!(json!({"type": "event", "event": "initialized"}));
}
if unity {
send!(json!({"type": "event", "event": "initialized"}));
}
}
"launch" | "attach" => {
if unity {
ok!(msg, Value::Null);
continue;
}
if script.gdb15_starts_at_launch {
// GDB 15 starts the program here and answers `launch` right away.
running = true;
@@ -448,7 +460,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
tokio::time::sleep(Duration::from_millis(50)).await;
ok!(msg, json!({"threads": [{"id": 1, "name": "\"main\"@1"}]}));
}
"threads" => ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]})),
"threads" => {
thread_requests += 1;
if thread_requests <= script.empty_thread_responses {
ok!(msg, json!({"threads": []}));
} else {
ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]}));
}
}
"stackTrace" => ok!(
msg,
json!({"stackFrames": [
@@ -878,6 +897,32 @@ async fn stop_terminates_and_disconnects() {
assert!(h.manager.threads(id).await.is_err());
}
#[tokio::test]
async fn unity_attach_waits_for_mono_and_disconnects_without_terminating_editor() {
let h = harness(Script { empty_thread_responses: 2, ..Script::default() });
h.manager.set_breakpoints(PathBuf::from("/p/a.cs"), vec![bp(4)]).await.unwrap();
let start = h.start(LaunchConfig {
adapter: "unity".into(),
request: "attach".into(),
program: None,
extra_json: Some(json!({ "name": "Unity Editor (42)", "__exceptionOptions": [] }).to_string()),
..config()
});
let ready = async {
h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;
let commands = h.commands();
let before_breakpoints = commands.iter().take_while(|c| *c != "setBreakpoints");
assert!(before_breakpoints.filter(|c| *c == "threads").count() >= 3);
assert!(commands.iter().any(|c| c == "setBreakpoints"));
};
let (id, ()) = tokio::join!(start, ready);
let id = id.unwrap();
assert_eq!(h.request("attach")["arguments"]["name"], "Unity Editor (42)");
h.manager.stop(id).await.unwrap();
assert!(!h.commands().iter().any(|c| c == "launch" || c == "terminate"));
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], false);
}
#[tokio::test]
async fn concurrent_sessions_are_independent() {
let h = harness(Script::default());
+187
Переглянути файл
@@ -0,0 +1,187 @@
//! Lists the Unity Editors to attach to through UnityDebug's discovery (`unity-debug list`).
use crate::{
adapter,
attach::{AttachKind, AttachableProcess},
};
use ide_core::{IdeError, IdeResult};
use std::{path::PathBuf, process::Stdio, time::Duration};
/// Waits until Mono reports its threads.
pub(crate) async fn wait_for_threads(session: &crate::session::Session) -> IdeResult<()> {
tokio::time::timeout(Duration::from_secs(20), async {
loop {
let body = session.conn.request_timeout("threads", serde_json::json!({}), Duration::from_secs(5)).await?;
if body.get("threads").and_then(serde_json::Value::as_array).is_some_and(|t| !t.is_empty()) {
return Ok(());
}
tokio::time::sleep(Duration::from_millis(100)).await;
}
})
.await
.map_err(|_| {
IdeError::unavailable(
"Unity debugger did not become ready. Enable Editor Attaching and Debug Mode in Unity, then retry.",
)
})?
}
// Mono binds breakpoints asynchronously and resumes threads itself during startup: wait for that burst to end.
pub(crate) async fn settle_startup(session: &crate::session::Session) {
*session.unity_startup_activity.lock() = std::time::Instant::now();
let _ = tokio::time::timeout(Duration::from_secs(3), async {
while session.unity_startup_activity.lock().elapsed() < Duration::from_secs(1) {
tokio::time::sleep(Duration::from_millis(50)).await;
}
})
.await;
}
pub fn require_runtime(cwd: &std::path::Path) -> IdeResult<()> {
if cfg!(unix) && ide_core::tool_path::find_command("mono", &ide_core::tool_path::search_path(), cwd).is_none() {
return Err(IdeError::unavailable(
"Unity Debugger requires Mono. Install Mono, make sure mono is on PATH, then refresh the Unity process list.",
));
}
Ok(())
}
const NOT_INSTALLED: &str = "debug adapter `unity` not found. Install Unity Debugger in Settings > Language Servers or configure the unity-debug tool path";
pub async fn editors(command: Option<String>, cwd: PathBuf) -> IdeResult<Vec<AttachableProcess>> {
require_runtime(&cwd)?;
let command = command.unwrap_or_else(|| "unity-debug".into());
let lookup = command.clone();
let dir = cwd.clone();
let binary = tokio::task::spawn_blocking(move || adapter::resolve_binary(&lookup, &dir))
.await
.map_err(|e| IdeError::internal(e.to_string()))?
.ok_or_else(|| IdeError::unavailable(NOT_INSTALLED))?;
let mut cmd = tokio::process::Command::new(binary);
ide_core::process::prepare(cmd.as_std_mut());
cmd.arg("list")
.current_dir(&cwd)
.env("PATH", ide_core::tool_path::search_path())
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
let out = tokio::time::timeout(Duration::from_secs(15), cmd.output())
.await
.map_err(|_| {
IdeError::unavailable("Unity process discovery timed out. Check that Unity Editor is responsive.")
})?
.map_err(|e| IdeError::unavailable(format!("Cannot start Unity process discovery: {e}")))?;
if !out.status.success() {
return Err(IdeError::unavailable(format!(
"Unity process discovery failed: {}",
String::from_utf8_lossy(&out.stderr).trim()
)));
}
let mut rows = parse_editors(&String::from_utf8_lossy(&out.stdout));
#[cfg(windows)]
if !rows.is_empty() {
match editor_process_ids() {
Ok(editors) => rows.retain(|p| editors.contains(&p.pid)),
Err(error) => tracing::warn!(%error, "Unity process filtering failed; using adapter discovery results"),
}
}
// The Editor of the open project comes first; the user picks which one to attach to.
let path = cwd.join("Library/EditorInstance.json");
let pid = std::fs::File::open(path).ok().and_then(|file| {
use std::io::Read;
let json: serde_json::Value = serde_json::from_reader(file.take(4096)).ok()?;
json.get("process_id")?.as_u64().and_then(|n| u32::try_from(n).ok())
});
for row in &mut rows {
if Some(row.pid) == pid {
row.command_line = cwd.to_string_lossy().into_owned();
}
}
rows.sort_by_key(|p| Some(p.pid) != pid);
Ok(rows)
}
#[cfg(windows)]
fn editor_process_ids() -> IdeResult<std::collections::HashSet<u32>> {
use std::collections::HashMap;
use windows_sys::Win32::{
Foundation::{CloseHandle, INVALID_HANDLE_VALUE},
System::Diagnostics::ToolHelp::{
CreateToolhelp32Snapshot, PROCESSENTRY32W, Process32FirstW, Process32NextW, TH32CS_SNAPPROCESS,
},
};
let mut unity = HashMap::new();
// The adapter also finds the asset import worker processes: keep the Unity processes whose parent isn't Unity.
unsafe {
let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if snapshot == INVALID_HANDLE_VALUE {
return Err(std::io::Error::last_os_error().into());
}
let mut entry = PROCESSENTRY32W { dwSize: std::mem::size_of::<PROCESSENTRY32W>() as u32, ..std::mem::zeroed() };
let mut found = Process32FirstW(snapshot, &mut entry);
if found == 0 {
let error = std::io::Error::last_os_error();
CloseHandle(snapshot);
return Err(error.into());
}
while found != 0 {
let end = entry.szExeFile.iter().position(|c| *c == 0).unwrap_or(entry.szExeFile.len());
let name = String::from_utf16_lossy(&entry.szExeFile[..end]);
if name.eq_ignore_ascii_case("Unity.exe") {
unity.insert(entry.th32ProcessID, entry.th32ParentProcessID);
}
found = Process32NextW(snapshot, &mut entry);
}
CloseHandle(snapshot);
}
Ok(unity.iter().filter_map(|(&pid, parent)| (!unity.contains_key(parent)).then_some(pid)).collect())
}
pub fn parse_editors(output: &str) -> Vec<AttachableProcess> {
let mut editors = Vec::new();
for line in output.lines() {
let line = line.trim().trim_start_matches('\u{feff}');
if !line.starts_with("Unity Editor (") {
continue;
}
// 3.0.1 prints `Unity Editor (Unity) (123)`; later versions append the project name.
let Some((name, pid, project)) = line.match_indices(" (").find_map(|(at, _)| {
let (id, project) = line[at + 2..].split_once(')')?;
let pid = id.parse::<u32>().ok().filter(|n| *n > 0)?;
Some((&line[..at], pid, project))
}) else {
continue;
};
if editors.iter().any(|p: &AttachableProcess| p.pid == pid) {
continue;
}
editors.push(AttachableProcess {
pid,
name: "Unity Editor".into(),
command_line: if project.trim().is_empty() { name.into() } else { project.trim().into() },
kind: AttachKind::Unity,
adapter: "unity".into(),
host: None,
port: None,
});
}
editors.sort_by(|a, b| a.command_line.cmp(&b.command_line).then(a.pid.cmp(&b.pid)));
editors
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_editor_ids_and_projects_without_mistaking_players_or_logs_for_editors() {
let rows = parse_editors(
"\u{feff}Unity Editor (Unity) (42) Game (Test)\r\nUnity Editor (7) My Game\nUnity Editor (42) duplicate\nWindowsPlayer (123) Player\nUnity Hub (44)\nUnity Editor (invalid)\nUnity Editor (0)\nlog text",
);
assert_eq!(rows.len(), 2);
assert_eq!((rows[0].pid, rows[0].command_line.as_str()), (42, "Game (Test)"));
assert_eq!(rows[1].pid, 7);
assert!(rows.iter().all(|p| p.kind == AttachKind::Unity && p.adapter == "unity"));
}
}
+187
Переглянути файл
@@ -0,0 +1,187 @@
//! Attaches to a real Unity Editor, with its own temporary project and Editor instance.
//! OPENIDEA_UNITY_EDITOR=<Unity.exe> OPENIDEA_UNITY_ADAPTER=<UnityDebug.exe>
//! cargo test -p ide-dap --test unity -- --ignored --nocapture
use ide_core::{IdeEvent, SharedSink, event::DebugEvent};
use ide_dap::{Breakpoint, DebugManager, LaunchConfig, SessionOwner, StepKind};
use ide_language::LanguageRegistry;
use parking_lot::Mutex;
use std::{collections::BTreeMap, path::PathBuf, sync::Arc, time::Duration};
const SCRIPT: &str = r#"using System.IO;
using UnityEditor;
using UnityEngine;
[InitializeOnLoad]
public static class OpenIdeaAttachProbe
{
static readonly string Root = Directory.GetParent(Application.dataPath).FullName;
static OpenIdeaAttachProbe()
{
EditorApplication.update += Tick;
}
static void Tick()
{
if (EditorApplication.isCompiling || EditorApplication.isUpdating) return;
if (!File.Exists(Path.Combine(Root, "ready")))
File.WriteAllText(Path.Combine(Root, "ready"), System.Diagnostics.Process.GetCurrentProcess().Id.ToString());
if (File.Exists(Path.Combine(Root, "exit"))) { EditorApplication.Exit(0); return; }
if (!File.Exists(Path.Combine(Root, "go"))) return;
File.Delete(Path.Combine(Root, "go"));
int result = Hit(41);
File.WriteAllText(Path.Combine(Root, "done"), result.ToString());
}
static int Hit(int seed)
{
int answer = seed + 1;
return answer;
}
}
"#;
async fn stopped(events: &Mutex<Vec<IdeEvent>>, expected_reason: &str) -> i64 {
for _ in 0..600 {
if let Some(thread) = events.lock().iter().find_map(|e| match e {
IdeEvent::Debug { event: DebugEvent::Stopped { thread_id, reason, .. }, .. }
if reason == expected_reason =>
{
Some(*thread_id)
}
_ => None,
}) {
return thread;
}
tokio::time::sleep(Duration::from_millis(50)).await;
}
let events = events.lock();
panic!("No breakpoint/step event: {:?}", &events[events.len().saturating_sub(16)..]);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[ignore = "needs a licensed Unity Editor and the Unity DAP adapter"]
async fn real_editor_attach_breakpoint_step_variables_and_detach() {
let editor = std::env::var("OPENIDEA_UNITY_EDITOR").expect("OPENIDEA_UNITY_EDITOR");
let adapter = std::env::var("OPENIDEA_UNITY_ADAPTER").expect("OPENIDEA_UNITY_ADAPTER");
let target = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target").canonicalize().unwrap();
// Keep the Editor log for diagnosing a failure.
let root = tempfile::Builder::new().prefix("unity-dap-smoke-").tempdir_in(target).unwrap().keep();
let root = root.to_string_lossy().trim_start_matches(r"\\?\").replace('\\', "/");
let root = PathBuf::from(root);
std::fs::create_dir_all(root.join("Assets/Editor")).unwrap();
std::fs::create_dir(root.join("ProjectSettings")).unwrap();
std::fs::create_dir(root.join("Packages")).unwrap();
std::fs::write(
root.join("ProjectSettings/ProjectVersion.txt"),
format!(
"m_EditorVersion: {}\n",
PathBuf::from(&editor).ancestors().nth(2).and_then(|p| p.file_name()).unwrap().to_string_lossy()
),
)
.unwrap();
std::fs::write(root.join("Packages/manifest.json"), r#"{"dependencies":{}}"#).unwrap();
let source = root.join("Assets/Editor/OpenIdeaAttachProbe.cs");
std::fs::write(&source, SCRIPT).unwrap();
let mut command = tokio::process::Command::new(&editor);
ide_core::process::prepare(command.as_std_mut());
// The test project has no packages: skip the package manager.
command
.args(["-batchmode", "-nographics", "-noUpm", "-debugCodeOptimization", "-projectPath"])
.arg(&root)
.arg("-logFile")
.arg(root.join("Editor.log"))
.current_dir(&root)
.kill_on_drop(true);
let mut child = command.spawn().unwrap();
let pid = child.id().unwrap();
eprintln!("Isolated Unity pid {pid}, project {}", root.display());
for _ in 0..1200 {
if root.join("ready").exists() {
break;
}
assert!(child.try_wait().unwrap().is_none(), "Unity exited; inspect {}/Editor.log", root.display());
tokio::time::sleep(Duration::from_millis(100)).await;
}
assert!(root.join("ready").exists(), "Editor failed to load the test script");
let rows = ide_dap::unity::editors(Some(adapter.clone()), root.clone()).await.unwrap();
assert!(rows.iter().any(|p| p.pid == pid), "test Editor absent: {rows:?}");
let events: Arc<Mutex<Vec<IdeEvent>>> = Arc::default();
let saved = events.clone();
let sink: SharedSink = Arc::new(move |event| saved.lock().push(event));
let manager = DebugManager::new(Arc::new(LanguageRegistry::from_configs(Vec::new())));
let line = SCRIPT.lines().position(|l| l.contains("int answer =")).unwrap() as u32;
manager
.set_breakpoints(
source.clone(),
vec![Breakpoint { line, condition: None, hit_condition: None, log_message: None, enabled: true }],
)
.await
.unwrap();
let start = || {
manager.start_with(
LaunchConfig {
name: format!("Unity Editor ({pid})"),
adapter: "unity".into(),
request: "attach".into(),
program: None,
args: vec![],
cwd: Some(root.clone().into()),
env: BTreeMap::new(),
extra_json: Some(
serde_json::json!({ "name": format!("Unity Editor ({pid})"), "__exceptionOptions": [] })
.to_string(),
),
},
SessionOwner::new("smoke", sink.clone()),
|_| Some(adapter.clone()),
)
};
let session = start().await.unwrap();
eprintln!("Attached; breakpoint states: {:?}", manager.breakpoint_states(&source));
// Mono is ready to run once the start returns.
assert!(!manager.threads(session).await.unwrap().is_empty());
std::fs::write(root.join("go"), "").unwrap();
let thread = stopped(&events, "breakpoint").await;
let frames = manager.stack_trace(session, thread).await.unwrap();
assert!(!frames.is_empty(), "Empty breakpoint stack: {:?}", events.lock());
assert_eq!(frames[0].line, line);
let scopes = manager.scopes(session, frames[0].id).await.unwrap();
let variables = manager.variables(session, scopes[0].variables_reference).await.unwrap();
assert!(variables.iter().any(|v| v.name == "seed" && v.value == "41"), "{variables:?}");
assert_eq!(manager.evaluate(session, Some(frames[0].id), "seed + 1".into()).await.unwrap().value, "42");
events.lock().clear();
manager.step(session, thread, StepKind::Over).await.unwrap();
let thread = stopped(&events, "step").await;
let frames = manager.stack_trace(session, thread).await.unwrap();
assert!(!frames.is_empty(), "Empty step stack: {:?}", events.lock());
assert!(frames[0].line > line);
// Detaching at a breakpoint resumes the Editor.
manager.stop(session).await.unwrap();
verify_resumed(&root, &mut child).await;
// Attaching again to the same Editor hits the existing breakpoint.
std::fs::remove_file(root.join("done")).unwrap();
events.lock().clear();
let session = start().await.unwrap_or_else(|error| {
let events = events.lock();
panic!("Reattach failed: {error:?}, recent events: {:?}", &events[events.len().saturating_sub(12)..]);
});
std::fs::write(root.join("go"), "").unwrap();
let thread = stopped(&events, "breakpoint").await;
assert_eq!(manager.stack_trace(session, thread).await.unwrap()[0].line, line);
manager.stop(session).await.unwrap();
verify_resumed(&root, &mut child).await;
std::fs::write(root.join("exit"), "").unwrap();
assert!(tokio::time::timeout(Duration::from_secs(30), child.wait()).await.unwrap().unwrap().success());
eprintln!("Verified discovery, attachment, breakpoint, locals, evaluation, step, detach and reattachment");
}
async fn verify_resumed(root: &std::path::Path, child: &mut tokio::process::Child) {
let path = root.join("done");
for _ in 0..100 {
assert!(child.try_wait().unwrap().is_none(), "disconnect terminated the Unity Editor");
if std::fs::read_to_string(&path).is_ok_and(|text| text == "42") {
return;
}
tokio::time::sleep(Duration::from_millis(100)).await;
}
panic!("Unity did not complete the script after disconnect: {:?}", std::fs::read_to_string(path));
}
+252
Переглянути файл
@@ -0,0 +1,252 @@
//! HTTP Client tools: list and run requests from project `.http` / `.rest` files.
use crate::mcp::tool::{Call, Output, Param, ParamType, Tool};
use ide_core::{IdeError, IdeResult};
use serde_json::json;
use std::path::Path;
/// Response body characters returned at most (keeps agent context bounded).
const MAX_BODY_CHARS: usize = 8_192;
pub fn tools() -> Vec<Tool> {
vec![http_list_requests(), http_run_request()]
}
fn is_http_file(path: &Path) -> bool {
path.extension()
.and_then(|e| e.to_str())
.is_some_and(|e| e.eq_ignore_ascii_case("http") || e.eq_ignore_ascii_case("rest"))
}
async fn resolve_http_file(call: &Call, path: &str) -> IdeResult<std::path::PathBuf> {
let path = call.resolve_inside(path)?;
if !is_http_file(&path) {
return Err(IdeError::invalid("path must be a .http or .rest file"));
}
if !path.is_file() {
return Err(IdeError::not_found(format!("No such file: {}", call.display(&path))));
}
Ok(path)
}
fn http_list_requests() -> Tool {
Tool::new(
"http_list_requests",
"Lists the HTTP requests in a project `.http` or `.rest` file (IntelliJ-style HTTP Client).
Returns each request's 0-based `index`, optional `name`, `method`, URL as written (variables not substituted), and `line`.
Use `http_run_request` with the same `path` and an `index` to send one.",
|call| async move {
let path = resolve_http_file(&call, &call.str("path")?).await?;
let text = crate::ops::fs::read_text(&call.host(), call.window(), path).await?;
let requests: Vec<_> = ide_http::parse::requests(&text)
.into_iter()
.map(|b| {
json!({
"index": b.index,
"name": b.name,
"method": b.method,
"url": b.url,
"line": b.line,
})
})
.collect();
Output::json(json!({ "requests": requests }))
},
)
.param(Param::required(
"path",
ParamType::String,
"Project-relative path to a `.http` or `.rest` file",
))
.output(json!({
"type": "object",
"properties": {
"requests": {
"type": "array",
"items": {
"type": "object",
"properties": {
"index": { "type": "integer" },
"name": { "type": ["string", "null"] },
"method": { "type": "string" },
"url": { "type": "string" },
"line": { "type": "integer" },
},
"required": ["index", "method", "url", "line"],
},
},
},
"required": ["requests"],
}))
}
fn truncate_chars(text: &str, max: usize) -> (String, bool) {
let count = text.chars().count();
if count <= max {
return (text.to_owned(), false);
}
(text.chars().take(max).collect(), true)
}
/// Drop resolved URLs from transport errors so MCP JSON does not echo env-substituted targets.
fn redact_transport_error(error: Option<String>, resolved_url: &str) -> Option<String> {
let error = error?;
let mut out = error.replace(resolved_url, "<url>");
// reqwest often embeds `https://host/...` even when the primary URL string differs slightly.
out = redact_urls(&out);
Some(out)
}
fn redact_urls(s: &str) -> String {
let mut out = String::with_capacity(s.len());
let mut rest = s;
loop {
// Prefer `https://` so we don't match the `http://` prefix inside it.
let start = match (rest.find("https://"), rest.find("http://")) {
(Some(a), Some(b)) => Some(a.min(b)),
(Some(a), None) => Some(a),
(None, Some(b)) => Some(b),
(None, None) => None,
};
let Some(start) = start else {
out.push_str(rest);
break;
};
out.push_str(&rest[..start]);
out.push_str("<url>");
let after = &rest[start..];
let end = after.find(|c: char| c.is_whitespace() || c == '\'' || c == '"' || c == ')').unwrap_or(after.len());
rest = &after[end..];
}
out
}
fn http_run_request() -> Tool {
Tool::new(
"http_run_request",
"Runs one request from a project `.http` or `.rest` file by 0-based `index`, using the IDE HTTP Client
(same as Run Request in the editor). Variables resolve from `http-client.env.json` / `http-client.private.env.json`
for the optional `env` name. Asks for confirmation with the resolved URL (and header names) first.
Returns status, timing and a truncated response body — not request headers or body (those may hold secrets).
The `url` field in the result is as written in the file (unsubstituted); transport errors redact URLs.",
|call| async move {
let rel = call.str("path")?;
let path = resolve_http_file(&call, &rel).await?;
let index =
call.opt_i64("index")?.ok_or_else(|| IdeError::invalid("missing or invalid argument `index`"))?;
if index < 0 {
return Err(IdeError::invalid("index must be >= 0"));
}
let index = index as u32;
let env = call.opt_str("env")?;
let text = crate::ops::fs::read_text(&call.host(), call.window(), path.clone()).await?;
let blocks = ide_http::parse::requests(&text);
let block =
blocks.get(index as usize).ok_or_else(|| IdeError::not_found(format!("no request #{}", index + 1)))?;
let input = ide_http::RunInput {
text: &text,
index,
file: Some(&path),
root: Some(call.root()),
env: env.as_deref(),
};
// Prepare before confirm so the dialog shows the real destination (after env substitution).
let prepared = ide_http::prepare(&input)?;
let subject = prepared.name.clone().unwrap_or_else(|| format!("{} {}", prepared.method, prepared.url));
let headers: Vec<_> = prepared.headers.iter().map(|(k, _)| k.as_str()).collect();
let mut detail = format!("{} {}\nFile: {rel}\nIndex: {index}", prepared.method, prepared.url);
if let Some(env) = &env {
detail.push_str(&format!("\nEnvironment: {env}"));
}
if !headers.is_empty() {
detail.push_str(&format!("\nHeaders: {}", headers.join(", ")));
}
if prepared.body.is_some() {
detail.push_str("\nBody: present");
}
call.confirm(&subject, Some(detail)).await?;
let exchange = ide_http::run(input, &call.cancel).await?;
let history = call.project().http_history.clone();
let saved = exchange.clone();
let _ = call.host().blocking(move || history.add(&saved)).await;
let (body, body_truncated) = match exchange.response.as_ref().and_then(|r| r.body.as_deref()) {
Some(b) => {
let (t, truncated) = truncate_chars(b, MAX_BODY_CHARS);
(Some(t), truncated)
}
None => (None, false),
};
let response = exchange.response.as_ref();
Output::json(json!({
"index": index,
"name": block.name,
"method": block.method,
"url": block.url,
"status": response.map(|r| r.status),
"statusText": response.map(|r| r.status_text.clone()),
"totalMs": response.map(|r| r.total_ms).or(exchange.entry.total_ms),
"error": redact_transport_error(exchange.entry.error.clone(), &prepared.url),
"body": body,
"bodyTruncated": body_truncated,
}))
},
)
.write()
.param(Param::required("path", ParamType::String, "Project-relative path to a `.http` or `.rest` file"))
.param(Param::required("index", ParamType::Integer, "0-based request index from `http_list_requests`"))
.param(Param::optional(
"env",
ParamType::String,
"Environment name from `http-client.env.json` / `http-client.private.env.json`",
))
.output(json!({
"type": "object",
"properties": {
"index": { "type": "integer" },
"name": { "type": ["string", "null"] },
"method": { "type": "string" },
"url": { "type": "string" },
"status": { "type": ["integer", "null"] },
"statusText": { "type": ["string", "null"] },
"totalMs": { "type": ["number", "null"] },
"error": { "type": ["string", "null"] },
"body": { "type": ["string", "null"] },
"bodyTruncated": { "type": "boolean" },
},
"required": ["index", "method", "url", "bodyTruncated"],
}))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn accepts_http_and_rest_extensions() {
assert!(is_http_file(Path::new("a.http")));
assert!(is_http_file(Path::new("a.REST")));
assert!(!is_http_file(Path::new("a.txt")));
}
#[test]
fn truncates_long_bodies() {
let long = "x".repeat(MAX_BODY_CHARS + 10);
let (t, truncated) = truncate_chars(&long, MAX_BODY_CHARS);
assert!(truncated);
assert_eq!(t.chars().count(), MAX_BODY_CHARS);
assert_eq!(truncate_chars("ok", MAX_BODY_CHARS), ("ok".into(), false));
}
#[test]
fn redacts_urls_in_transport_errors() {
let url = "https://secret.example/v1?token=abc";
assert_eq!(
redact_transport_error(Some(format!("error sending request for {url}")), url).as_deref(),
Some("error sending request for <url>")
);
assert_eq!(redact_urls("fail https://a.example/x and http://b/y"), "fail <url> and <url>");
}
}
+2
Переглянути файл
@@ -7,6 +7,7 @@ pub(crate) mod run;
mod vcs;
pub use requests::Requests;
mod files;
mod http;
mod page;
mod reports;
mod search;
@@ -39,6 +40,7 @@ fn tools() -> Vec<tool::Tool> {
tools.extend(edit::tools());
tools.extend(run::tools());
tools.extend(vcs::tools());
tools.extend(http::tools());
tools
}
+86 -11
Переглянути файл
@@ -641,6 +641,82 @@ pub async fn maven_exclude_dependency(
.map_err(join_err)?
}
/// Build / Rebuild / Build Artifacts of a Java project without a build tool, from its
/// Project Structure; `None` when it has no Java sources under its source roots.
fn structure_plan(
root: &Path,
settings: &Settings,
detected: &[ide_workspace::roots::SourceFolder],
kind: BuildKind,
cache: &Path,
) -> IdeResult<Option<compile::BuildPlan>> {
let (ps, roots, jdk) = structure_inputs(root, settings, detected);
compile::structure_plan(root, &ps, &roots, jdk.as_ref(), &settings.languages.java.language_level, kind, cache)
}
/// The Project Structure, roots and JDK a build of a project without a build tool uses.
/// An Eclipse project's `.classpath` libraries and its web content folder count as if they
/// were configured, and a web project with no artifacts gets IDEA's `<name>:war exploded`.
pub(crate) fn structure_inputs(
root: &Path,
settings: &Settings,
detected: &[ide_workspace::roots::SourceFolder],
) -> (ide_core::settings::ProjectStructureSettings, compile::StructureRoots, Option<compile::StructureJdk>) {
use ide_core::settings::{ArtifactConfig, ArtifactKind, FacetConfig, ProjectLibrary};
use ide_workspace::roots::{ProjectRoots, RootKind, eclipse};
let mut ps = settings.project_structure.clone();
let mut included = Vec::new();
if let Some(cp) = eclipse::classpath(root).filter(|cp| !cp.libraries.is_empty()) {
let name = "Eclipse classpath".to_owned();
if !ps.libraries.iter().any(|l| l.name == name) {
ps.libraries.push(ProjectLibrary { name: name.clone(), classes: cp.libraries, ..Default::default() });
}
included.push(name);
}
if !ps.facets.iter().any(|f| f.kind == "web")
&& let Some(web) = eclipse::web_root(root)
{
ps.facets.push(FacetConfig {
kind: "web".into(),
module: ".".into(),
descriptor: format!("{web}/WEB-INF/web.xml"),
web_root: web,
});
if ps.artifacts.is_empty() {
let name = root.file_name().map_or_else(|| "app".into(), |n| n.to_string_lossy().into_owned());
ps.artifacts.push(ArtifactConfig {
name: format!("{name}:war exploded"),
kind: ArtifactKind::WarExploded,
module: ".".into(),
include_libraries: included,
..Default::default()
});
}
}
let roots = ProjectRoots::compute(detected.to_vec(), &ps);
let of = |kind: RootKind| roots.roots.iter().filter(|r| r.kind == kind).map(|r| root.join(&r.path)).collect();
let module = ps.module_settings(root, root);
let level = module
.map(|m| m.language_level.as_str())
.filter(|l| !l.trim().is_empty())
.unwrap_or(&settings.languages.java.language_level);
// Without a configured SDK, an installed JDK that can compile the language level.
let jdk = ide_sdk::apply::module_jdk(root, root, settings)
.or_else(|| {
let installed = ide_sdk::java::installed_jdks();
ide_sdk::java::pick_jdk(&installed, compile::language_release(level)).cloned()
})
.map(|j| compile::StructureJdk { home: j.home, major: j.major });
let roots = compile::StructureRoots {
sources: of(RootKind::Source),
tests: of(RootKind::Test),
resources: of(RootKind::Resources),
test_resources: of(RootKind::TestResources),
excluded: of(RootKind::Excluded),
};
(ps, roots, jdk)
}
fn cmake_plan(root: &Path, kind: BuildKind, configs: &[ide_run::RunConfig], id: &str) -> IdeResult<compile::BuildPlan> {
let commands = ide_run::cmake_build_configs(configs, id)?;
let title = commands.last().map(|c| c.name.clone()).unwrap_or_default();
@@ -675,6 +751,7 @@ pub async fn build_run(
let project = host.project(window)?;
let (root, cache, sink) = (project.root.clone(), project.build_cache_dir(), project.sink.clone());
let settings = project.settings.effective();
let detected = project.detected_roots.read().clone();
let config_dir = host.config_dir.clone();
let token = host.begin_project_request(window, request);
let result = tokio::task::spawn_blocking(move || {
@@ -738,17 +815,15 @@ pub async fn build_run(
plan.title = workspace.name;
plan
} else {
prepare_plan(
compile::plan(
&root,
&with_profiles(load(&root, &cache, &settings), &cache),
kind,
file.as_deref(),
settings.cmake.profiles.as_deref(),
)?,
&root,
&settings,
)
let model = with_profiles(load(&root, &cache, &settings), &cache);
match compile::plan(&root, &model, kind, file.as_deref(), settings.cmake.profiles.as_deref()) {
Ok(plan) => prepare_plan(plan, &root, &settings),
// No build tool: a Java project builds from its Project Structure.
Err(e) if e.kind == ide_core::error::ErrorKind::NotFound => {
structure_plan(&root, &settings, &detected, kind, &cache)?.ok_or(e)?
}
Err(e) => return Err(e),
}
};
let result = compile::run(&root, &plan, &token, &|e| {
let _ = on_event.send(e);
+45
Переглянути файл
@@ -12,6 +12,25 @@ use std::path::PathBuf;
/// Starts a session owned by this window: its events (and those of child sessions) go here only.
pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> IdeResult<DebugSessionId> {
host.require_trust(window)?;
let unity_pid = if config.adapter == "unity" {
if config.request != "attach" {
return Err(ide_core::IdeError::invalid("Unity debugging only supports attachment to a running Editor"));
}
let arguments = launch_arguments(&config)?;
let pid = arguments["name"]
.as_str()
.and_then(|name| name.strip_prefix("Unity Editor ("))
.and_then(|name| name.strip_suffix(')'))
.and_then(|pid| pid.parse::<u32>().ok());
if let Some(pid) = pid {
require_unity_editor(pid)?;
}
let cwd = config.cwd.as_ref().map(|path| path.as_ref()).unwrap_or_else(|| std::path::Path::new("."));
unity::require_runtime(cwd)?;
pid
} else {
None
};
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
if config.adapter == "debugpy"
&& config.request == "launch"
@@ -100,12 +119,26 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
let server_port = debug_server_port(&config);
let result = host.debugger.start_with(config, owner, custom).await;
flush_output();
if result.is_err()
&& let Some(pid) = unity_pid
{
require_unity_editor(pid)?;
}
if let (Ok(id), Some(port)) = (&result, server_port) {
attach_jvm_inspector(host, window, *id, port);
}
result
}
fn require_unity_editor(pid: u32) -> IdeResult<()> {
if !ide_core::process::process_alive(pid) {
return Err(ide_core::IdeError::unavailable(format!(
"Unity Editor (PID {pid}) is no longer running. Refresh the Unity process list and select a running Editor."
)));
}
Ok(())
}
/// The port of the java-debug server this machine's jdtls started; `debugServer` as `host:port`
/// names an adapter on another machine, whose jdtls is not ours to ask.
fn debug_server_port(config: &LaunchConfig) -> Option<u16> {
@@ -460,6 +493,17 @@ pub async fn debug_free_port(host: &Host, window: &str) -> IdeResult<u16> {
ide_dap::adapter::free_port().map_err(ide_core::IdeError::from)
}
pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
host.require_trust(window)?;
let project = host.project(window)?;
if ide_workspace::unity::detect(&project.root).is_none() {
return Err(ide_core::IdeError::invalid("Open a Unity project before attaching to the Editor"));
}
let command = ide_sdk::apply::tool_command(&project.root, &project.settings.effective(), "unity-debug")
.map(|p| p.to_string_lossy().into_owned());
unity::editors(command, project.root.clone()).await
}
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
pub async fn debug_listen_for_jvm(
@@ -664,6 +708,7 @@ pub(crate) fn register(d: &mut Dispatcher) {
});
d.add("debug_attachable_processes", |c| async move { debug_attachable_processes(&c.host, &c.window).await });
d.add("debug_free_port", |c| async move { debug_free_port(&c.host, &c.window).await });
d.add("debug_unity_processes", |c| async move { debug_unity_processes(&c.host, &c.window).await });
d.add("debug_listen_for_jvm", |c| async move {
debug_listen_for_jvm(&c.host, &c.window, c.arg("request")?, c.arg("host")?, c.arg("port")?).await
});
+48
Переглянути файл
@@ -1057,6 +1057,11 @@ pub async fn lsp_apply_code_action(host: &Host, window: &str, doc: DocId, action
blocking(move || apply_edit(&documents, &edit)).await?;
}
open_plugin_action_target(&action, window);
if let Some(command) = &action.command
&& let Some(result) = run_plugin_server_command(host, window, doc, None, command).await
{
return result;
}
if let Some(command) = action.command
&& !(action.edit.is_some() && is_client_follow_up(&project, doc, None, &command).await)
{
@@ -1608,9 +1613,47 @@ pub async fn lsp_execute_command(host: &Host, window: &str, doc: DocId, command:
return blocking(move || plugins.run_language_command(&plugin, &command_id, argument.as_deref(), invocation))
.await;
}
if let Some(result) = run_plugin_server_command(host, window, doc, None, &command).await {
return result;
}
host.project(window)?.lsp.execute_command(doc, command).await
}
/// Runs `command` through the plugin that claims it (`[[contributes.serverCommands]]`)
/// when no server of the document executes it itself: a code lens, code action or inlay
/// hint may carry a command the server leaves to the client. `None` when no plugin does.
async fn run_plugin_server_command(
host: &Host,
window: &str,
doc: DocId,
server: Option<ServerId>,
command: &Command,
) -> Option<IdeResult<()>> {
let plugins = crate::plugins::editor_plugin_host()?;
let project = host.project(window).ok()?;
if project.lsp.provides_command(doc, server, &command.command).await {
return None;
}
let (plugin, run) = plugins.server_command(&project.lsp.server_names(doc, server), &command.command)?;
let snap = match project.documents.snapshot(doc) {
Ok(snap) => snap,
Err(e) => return Some(Err(e)),
};
let invocation = ide_plugin::Invocation {
client: Some(window.into()),
workspace_root: Some(project.root.clone()),
editor: Some(ide_plugin::EditorContext {
path: snap.path.0.clone(),
language: snap.language.0,
selections: vec![],
}),
selected_paths: vec![snap.path.0],
..Default::default()
};
let arguments = serde_json::Value::Array(command.arguments.clone()).to_string();
Some(blocking(move || plugins.run_language_command(&plugin, &run, Some(&arguments), invocation)).await)
}
/// Resolves an interactive command without applying edits or executing it.
pub async fn lsp_resolve_command(
host: &Host,
@@ -1652,6 +1695,11 @@ pub async fn lsp_execute_code_action(
.await
.map_err(|e| ide_core::IdeError::internal(e.to_string()))??;
}
if let Some(command) = &action.command
&& let Some(result) = run_plugin_server_command(host, window, doc, Some(action.server), command).await
{
return result.map(|()| Vec::new());
}
match action.command {
Some(command) if edited && is_client_follow_up(&project, doc, Some(action.server), &command).await => {
Ok(Vec::new())
+28 -9
Переглянути файл
@@ -54,8 +54,9 @@ pub fn index_file_extensions(host: &Host, window: &str) -> IdeResult<Vec<Extensi
Ok(host.project(window)?.index.file_extensions())
}
pub fn find_files(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
Ok(host.project(window)?.index.find_files(&query, limit as usize))
pub async fn find_files(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
let project = host.project(window)?;
blocking(move || Ok(project.index.find_files(&query, limit as usize))).await
}
pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeResult<Vec<IpcPath>> {
@@ -63,18 +64,33 @@ pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeRes
blocking(move || Ok(project.index.files_named(&name).into_iter().map(Into::into).collect())).await
}
pub fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
Ok(host.project(window)?.index.find_dirs(&query, limit as usize))
pub async fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
let project = host.project(window)?;
blocking(move || Ok(project.index.find_dirs(&query, limit as usize))).await
}
pub fn find_symbols(
pub async fn find_symbols(
host: &Host,
window: &str,
query: String,
filter: SymbolFilter,
limit: u32,
) -> IdeResult<Vec<SymbolMatch>> {
Ok(host.project(window)?.index.find_symbols(&query, filter, limit as usize))
let project = host.project(window)?;
blocking(move || Ok(project.index.find_symbols(&query, filter, limit as usize))).await
}
/// Index symbols named exactly one of `names` inside `within` (an agent task's folder),
/// at most `SYMBOLS_PER_NAME` each: every name an agent reply shows, in one lookup.
pub async fn find_symbols_named(
host: &Host,
window: &str,
names: Vec<String>,
within: IpcPath,
) -> IdeResult<Vec<SymbolMatch>> {
const SYMBOLS_PER_NAME: usize = 50;
let project = host.project(window)?;
blocking(move || Ok(project.index.symbols_named_any(&names, &PathBuf::from(within), SYMBOLS_PER_NAME))).await
}
pub fn mark_recent(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
@@ -318,11 +334,14 @@ pub async fn web_unresolved_references(host: &Host, window: &str, doc: DocId) ->
pub(crate) fn register(d: &mut Dispatcher) {
d.add("index_status", |c| async move { index_status(&c.host, &c.window) });
d.add("index_file_extensions", |c| async move { index_file_extensions(&c.host, &c.window) });
d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?) });
d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
d.add("find_files_named", |c| async move { find_files_named(&c.host, &c.window, c.arg("name")?).await });
d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?) });
d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
d.add("find_symbols", |c| async move {
find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?)
find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?).await
});
d.add("find_symbols_named", |c| async move {
find_symbols_named(&c.host, &c.window, c.arg("names")?, c.arg("within")?).await
});
d.add("mark_recent", |c| async move { mark_recent(&c.host, &c.window, c.arg("path")?) });
d.add("remove_recent", |c| async move { remove_recent(&c.host, &c.window, c.arg("path")?) });
+82 -2
Переглянути файл
@@ -202,12 +202,86 @@ pub async fn run_tomcat_installations(
.map_err(|e| IdeError::internal(e.to_string()))
}
/// Id prefix of a Project Structure WAR artifact (a project without a build tool).
const PROJECT_ARTIFACT: &str = "project:";
fn project_web_artifacts(ps: &ide_core::settings::ProjectStructureSettings) -> Vec<ide_build::web::WebArtifact> {
ide_build::compile::structure_web_artifacts(ps)
.into_iter()
.map(|a| ide_build::web::WebArtifact {
id: format!("{PROJECT_ARTIFACT}{}", a.name),
name: a.name.split(':').next().unwrap_or(&a.name).to_owned(),
module: if a.module == "." { String::new() } else { a.module.clone() },
tool: "project".into(),
})
.collect()
}
/// Compiles the project and packs the Project Structure artifact `name` as the WAR Tomcat
/// deploys, recorded in `base` like a build tool's archive.
fn build_project_war(
root: &std::path::Path,
settings: &ide_core::settings::Settings,
detected: &[ide_workspace::roots::SourceFolder],
name: &str,
base: &std::path::Path,
cache: &std::path::Path,
) -> IdeResult<()> {
use ide_build::compile;
let (ps, roots, jdk) = crate::ops::build::structure_inputs(root, settings, detected);
let artifact = ps
.artifacts
.iter()
.find(|a| a.name == name)
.ok_or_else(|| IdeError::invalid(format!("No artifact named {name} in Project Structure › Artifacts")))?;
let war = base.join("artifact").join(format!(
"{}.war",
name.split(':').next().unwrap_or(name).replace(|c: char| !c.is_alphanumeric() && c != '-', "_")
));
let plan = compile::structure_war_plan(
root,
&ps,
&roots,
jdk.as_ref(),
&settings.languages.java.language_level,
artifact,
&war,
cache,
)?;
let result = compile::run(root, &plan, &ide_core::CancellationToken::new(), &|_| {})?;
if !result.success {
let first = result.messages.iter().find(|m| m.severity == ide_core::Severity::Error);
let text = match first {
Some(m) => match (&m.path, m.range) {
(Some(path), Some(range)) => {
format!("{}:{}: {}", std::path::PathBuf::from(path.clone()).display(), range.start.line + 1, m.text)
}
_ => m.text.clone(),
},
None => "the build failed".into(),
};
return Err(IdeError::invalid(format!("Cannot build {name}: {text}")));
}
std::fs::create_dir_all(base)?;
std::fs::write(base.join("artifact-id.txt"), format!("{PROJECT_ARTIFACT}{name}"))?;
std::fs::write(base.join("artifact-path.txt"), war.to_string_lossy().as_bytes())?;
Ok(())
}
pub async fn run_tomcat_artifacts(host: &Host, window: &str) -> IdeResult<Vec<ide_build::web::WebArtifact>> {
host.require_trust(window)?;
let project = host.project(window)?;
tokio::task::spawn_blocking(move || {
let model = crate::ops::build::load(&project.root, &project.build_cache_dir(), &project.settings.effective());
ide_build::web::artifacts(&project.root, &model)
let settings = project.settings.effective();
let model = crate::ops::build::load(&project.root, &project.build_cache_dir(), &settings);
let mut artifacts = ide_build::web::artifacts(&project.root, &model);
// Without a build tool, the Project Structure's WAR artifacts are built by the IDE.
if model.maven.is_none() && model.gradle.is_empty() {
let detected = project.detected_roots.read().clone();
let (ps, _, _) = crate::ops::build::structure_inputs(&project.root, &settings, &detected);
artifacts.extend(project_web_artifacts(&ps));
}
artifacts
})
.await
.map_err(|e| IdeError::internal(e.to_string()))
@@ -230,6 +304,12 @@ pub async fn run_tomcat_build(host: &Host, window: &str, config: RunConfig) -> I
.or_else(|| artifacts.first().map(|a| &a.id))
.ok_or_else(|| IdeError::invalid("Choose a WAR artifact"))?;
let base = ide_run::tomcat::effective_base_dir(&project.root, &project.cache_dir, &config)?;
if let Some(name) = id.strip_prefix(PROJECT_ARTIFACT) {
let settings = project.settings.effective();
let detected = project.detected_roots.read().clone();
build_project_war(&project.root, &settings, &detected, name, &base, &project.build_cache_dir())?;
return Ok(None);
}
// "Build before launch" is skipped when the built WAR is already newer than the
// sources of every module in the build, so a repeated run does not rebuild (IDEA's
// up-to-date check) but a change in a dependency module does.
+29
Переглянути файл
@@ -313,6 +313,35 @@ impl PluginHost {
}
}
impl PluginHost {
/// The plugin command that runs `command`, which one of the language servers
/// `servers` handed to the client (`[[contributes.serverCommands]]`): the plugin
/// and its command id. A plugin counts while it holds `lsp:<server>`; when several
/// claim the same server and command, the first one loaded keeps it.
pub(crate) fn server_command(&self, servers: &[String], command: &str) -> Option<(String, String)> {
let mut claims = self.ui.items(super::ui_points::SERVER_COMMANDS, None).into_iter().filter_map(|item| {
let decl: super::ui_points::ServerCommandDecl = serde_json::from_value(item.decl).ok()?;
let claimed = decl.command == command && servers.contains(&decl.server);
let grant = ide_extension::Capability::Lsp(decl.server.clone());
let granted = claimed
&& self.get(&item.plugin_id).is_ok_and(|p| p.meta.lock().granted.iter().any(|g| g.covers(&grant)));
granted.then_some((item.plugin_id, decl.server, decl.run))
});
let (plugin, server, run) = claims.next()?;
for (other, _, _) in claims.filter(|(other, s, _)| *other != plugin && *s == server) {
static LOGGED: parking_lot::Mutex<std::collections::BTreeSet<(String, String, String)>> =
parking_lot::Mutex::new(std::collections::BTreeSet::new());
if LOGGED.lock().insert((other.clone(), server.clone(), command.to_owned())) {
tracing::warn!(
"plugins {plugin} and {other} both claim command `{command}` of language server {server}; \
{plugin} was loaded first and keeps it"
);
}
}
Some((plugin, run))
}
}
pub(crate) fn signature_help(h: SignatureHelp) -> ide_lsp::types::SignatureHelp {
let signatures: Vec<_> = h
.signatures
+1
Переглянути файл
@@ -93,6 +93,7 @@ pub fn register_builtin_points(
registry.register(Arc::new(UiPoint::new(p::FILE_ICONS, ui.clone(), p::file_icon)))?;
registry.register(Arc::new(UiPoint::new(p::FILE_TEMPLATES, ui.clone(), p::file_template)))?;
registry.register(Arc::new(UiPoint::new(p::COMMIT_CHECKS, ui.clone(), p::commit_check)))?;
registry.register(Arc::new(UiPoint::new(p::SERVER_COMMANDS, ui.clone(), p::server_command)))?;
registry.register(Arc::new(UiPoint::new(ide_extension::LOCALES_POINT, ui.clone(), p::locales)))?;
Ok(())
}
+37
Переглянути файл
@@ -46,6 +46,11 @@
//! id = "conventional"
//! title = "Conventional Commits" # Commit Options › Before Commit; `commit-checker.check` runs it
//!
//! [[contributes.serverCommands]]
//! server = "phoxite" # the language server whose results carry the command
//! command = "laravel.modelView" # a command the server leaves to the client
//! run = "model-view" # this plugin's command; needs `lsp:phoxite`
//!
//! [[contributes.fileTemplates]]
//! id = "drawing"
//! name = "Excalidraw Drawing"
@@ -72,6 +77,7 @@ pub const FILE_ICONS: &str = "fileIcons";
pub const MARKER_ICONS: &str = "markerIcons";
pub const FILE_TEMPLATES: &str = "fileTemplates";
pub const COMMIT_CHECKS: &str = "commitChecks";
pub const SERVER_COMMANDS: &str = "serverCommands";
const VIEW_ITEM_MENU: &str = "viewItem.context";
/// The toolbar above the commit message (Commit tool window and dialog).
@@ -964,6 +970,37 @@ pub(super) fn commit_check(pkg: &Package, decl: toml::Value) -> Result<UiDecl, S
Ok(UiDecl::new(d.id.clone(), d.title.clone(), json(&d)?))
}
/// A command a language server's code lens, code action or inlay hint carries and
/// leaves to the client, and the plugin command that runs it.
#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub(super) struct ServerCommandDecl {
/// The server's name in its language definition.
pub(super) server: String,
pub(super) command: String,
/// The plugin's command (`[[contributes.commands]]`); it gets the arguments as JSON.
pub(super) run: String,
}
/// `[[contributes.serverCommands]]` (API 1.9): routes a command no server executes
/// itself to the plugin's own command.
pub(super) fn server_command(pkg: &Package, decl: toml::Value) -> Result<UiDecl, String> {
let d: ServerCommandDecl = decode(SERVER_COMMANDS, decl)?;
pkg.manifest.needs_api(&format!("contributes.{SERVER_COMMANDS}"), 9)?;
if d.command.is_empty() || d.command.len() > 256 {
return Err(format!("contributes.{SERVER_COMMANDS}: command names are 1–256 bytes"));
}
declared_command(pkg, SERVER_COMMANDS, &d.run)?;
let grant: ide_extension::Capability =
format!("lsp:{}", d.server).parse().map_err(|e| format!("contributes.{SERVER_COMMANDS}: {e}"))?;
if !pkg.manifest.capabilities.all().any(|c| *c == grant) {
return Err(format!(
"contributes.{SERVER_COMMANDS}: needs the `{grant}` capability (the command comes from that server)"
));
}
Ok(UiDecl::new(format!("{}:{}", d.server, d.command), d.command.clone(), json(&d)?))
}
const MAX_CATALOG_ENTRIES: usize = 20_000;
pub fn locale_asset(tag: &str) -> String {
+1
Переглянути файл
@@ -500,6 +500,7 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
| "find_files_named"
| "find_dirs"
| "find_symbols"
| "find_symbols_named"
| "mark_recent"
| "remove_recent"
| "recent_files"
+73
Переглянути файл
@@ -697,3 +697,76 @@ async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
let interrupted = h.json("wait_for_run", json!({"name": "interrupt", "timeout": 10000})).await;
assert_eq!(interrupted["state"], "stoppedByAgent", "{interrupted}");
}
#[tokio::test(flavor = "multi_thread")]
async fn http_list_and_run_require_confirmation() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let h = Harness::new();
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move {
let (mut socket, _) = listener.accept().await.unwrap();
let mut buf = [0u8; 1024];
let _ = socket.read(&mut buf).await;
let body = b"{\"ok\":true}";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
body.len(),
std::str::from_utf8(body).unwrap()
);
let _ = socket.write_all(response.as_bytes()).await;
});
std::fs::write(
h.root.join("api.http"),
format!(
"### Health\nGET http://{addr}/health\nAccept: application/json\n\n### Echo\n# @name echo\nGET http://{addr}/echo\n"
),
)
.unwrap();
std::fs::write(h.root.join("http-client.env.json"), r#"{"dev":{"unused":"x"}}"#).unwrap();
let listed = h.json("http_list_requests", json!({"path": "api.http"})).await;
assert_eq!(listed["requests"].as_array().unwrap().len(), 2, "{listed}");
assert_eq!(listed["requests"][0]["index"], 0);
assert_eq!(listed["requests"][0]["name"], "Health");
assert_eq!(listed["requests"][0]["method"], "GET");
assert_eq!(listed["requests"][1]["name"], "echo");
assert!(listed["requests"][0]["url"].as_str().unwrap().contains("/health"));
// Write tool is hidden until the project is trusted.
assert!(Registry::new(h.host.clone()).tools(&h.root).unwrap().iter().all(|t| t.name != "http_run_request"));
h.trust().await;
assert!(
Registry::new(h.host.clone())
.tools(&h.root)
.unwrap()
.iter()
.any(|t| t.name == "http_run_request" && !t.read_only)
);
h.host.mcp_requests.set_ready("main", true);
let denied = h.error("http_run_request", json!({"path": "api.http", "index": 0, "env": "dev"}));
let deny = async {
let id = h.request().await;
h.host.mcp_requests.answer("main", id, false, None).unwrap();
};
let (error, ()) = tokio::join!(denied, deny);
assert!(error.contains("denied by the user"), "{error}");
h.events.lock().unwrap().clear();
let run = h.json("http_run_request", json!({"path": "api.http", "index": 0, "env": "dev"}));
let allow = async {
let id = h.request().await;
h.host.mcp_requests.answer("main", id, true, None).unwrap();
};
let (result, ()) = tokio::join!(run, allow);
assert_eq!(result["status"], 200, "{result}");
assert_eq!(result["method"], "GET");
assert!(result["body"].as_str().unwrap().contains("ok"), "{result}");
assert_eq!(result["bodyTruncated"], false);
// Secrets must not appear as request headers/body in the tool payload.
assert!(result.get("headers").is_none(), "{result}");
assert!(result.get("request").is_none(), "{result}");
}
+184
Переглянути файл
@@ -0,0 +1,184 @@
//! `[[contributes.serverCommands]]` (plugin API 1.9): a command a language server hands to the
//! client runs the plugin command that claims it. The fixture's command sends its argument
//! back to the server (`mock/ran`), through the real component runtime and `language-servers`.
use ide_host::plugins::{Consent, HostWorkspace, PluginHost, set_editor_providers};
use ide_host::{Host, HostConfig, ops};
use ide_jsonrpc::{Handler, Peer};
use ide_lsp::types::Command;
use ide_plugin::Limits;
use parking_lot::Mutex;
use serde_json::{Value, json};
use std::{path::Path, sync::Arc, time::Duration};
const ID: &str = "test.lsp-requests";
const SECOND: &str = "test.lsp-second";
fn fixture() -> std::path::PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/lsp-requests")
}
/// The fixture under `dir` with `edit` applied to its manifest.
fn variant(dir: &Path, edit: impl Fn(&str) -> String) -> std::path::PathBuf {
fn copy(from: &Path, to: &Path) {
std::fs::create_dir_all(to).unwrap();
for entry in std::fs::read_dir(from).unwrap() {
let entry = entry.unwrap();
match entry.file_type().unwrap().is_dir() {
true if entry.file_name() != "target" => copy(&entry.path(), &to.join(entry.file_name())),
true => {}
false => drop(std::fs::copy(entry.path(), to.join(entry.file_name())).unwrap()),
}
}
}
copy(&fixture(), dir);
let manifest = dir.join("plugin.toml");
std::fs::write(&manifest, edit(&std::fs::read_to_string(&manifest).unwrap())).unwrap();
dir.to_path_buf()
}
/// A language server named `mock`: it executes `mock.own` itself and records what it gets.
#[derive(Default)]
struct Mock {
requests: Mutex<Vec<(String, Value)>>,
notifications: Mutex<Vec<(String, Value)>>,
}
impl Mock {
fn ran(&self) -> Vec<Value> {
self.notifications.lock().iter().filter(|(m, _)| m == "mock/ran").map(|(_, p)| p.clone()).collect()
}
fn executed(&self) -> Vec<Value> {
let requests = self.requests.lock();
requests.iter().filter(|(m, _)| m == "workspace/executeCommand").map(|(_, p)| p["command"].clone()).collect()
}
}
impl Handler for Mock {
fn on_notification(&self, method: &str, p: Value) {
self.notifications.lock().push((method.to_owned(), p));
}
fn on_request(&self, method: &str, p: Value) -> Result<Value, (i64, String)> {
self.requests.lock().push((method.to_owned(), p));
Ok(match method {
"initialize" => json!({ "capabilities": {
"textDocumentSync": { "openClose": true, "change": 1 },
"executeCommandProvider": { "commands": ["mock.own"] },
} }),
_ => Value::Null,
})
}
}
async fn eventually(what: &str, mut f: impl FnMut() -> bool) {
for _ in 0..500 {
if f() {
return;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
panic!("timed out waiting for {what}");
}
fn command(name: &str, arguments: Vec<Value>) -> Command {
Command { title: "Lens".into(), command: name.into(), arguments }
}
#[tokio::test(flavor = "multi_thread")]
async fn a_command_the_server_leaves_to_the_client_runs_the_plugin_that_claims_it() {
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap().join("project");
std::fs::create_dir(&root).unwrap();
let host = Arc::new(Host::new(HostConfig {
config_dir: tmp.path().join("config"),
data_dir: tmp.path().join("data"),
local_data_dir: tmp.path().join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(ide_core::NullSink)),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
}));
// Language servers start only in a trusted project.
host.set_project_trust(&root, true, false).await.unwrap();
host.open_project("main", &root).unwrap();
let plugins = Arc::new(
PluginHost::new(tmp.path().join("plugins"), Arc::new(|_: Option<&str>, _| {}), Limits::default()).unwrap(),
);
plugins.set_workspace(Some(Arc::new(HostWorkspace(Arc::downgrade(&host)))));
set_editor_providers(Some(&plugins));
// The manifest must hold the grant of the server whose commands it claims.
let ungranted = variant(&tmp.path().join("ungranted"), |m| m.replace("optional = [\"lsp:mock\"]", "optional = []"));
let err = plugins.install_from_dir(&ungranted, &Consent::all()).unwrap_err();
assert!(err.message.contains("needs the `lsp:mock` capability"), "{err:?}");
plugins.install_from_dir(&fixture(), &Consent::all()).unwrap();
// The server `mock` serves the project's text files.
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
let port = listener.local_addr().unwrap().port();
let mock = Arc::new(Mock::default());
let peers = Arc::new(Mutex::new(Vec::<Peer>::new()));
let (accepted, state) = (peers.clone(), mock.clone());
let server = tokio::spawn(async move {
while let Ok((stream, _)) = listener.accept().await {
let (r, w) = stream.into_split();
accepted.lock().push(Peer::connect(r, w, state.clone()));
}
});
let cfg: ide_language::LanguageServerConfig =
toml::from_str(&format!("name='mock'\ncommand='no-process-required'\nconnect='127.0.0.1:{port}'")).unwrap();
let project = host.project("main").unwrap();
project.lsp.set_servers_hook(Box::new(move |_, _| vec![cfg.clone()]));
let path = root.join("a.txt");
std::fs::write(&path, "class Post {}\n").unwrap();
let doc = ops::doc::open(&host, "main", path.clone()).await.unwrap().id;
project.lsp.did_open(
doc,
&path,
&ide_core::LanguageId::plain_text(),
0,
"class Post {}
",
);
eventually("the server to be ready", || {
project.lsp.servers().iter().any(|s| s.name == "mock" && s.status == ide_core::event::ServerStatus::Ready)
})
.await;
// A lens command the server does not execute: the plugin's command gets the arguments as JSON.
let lens = command("mock.modelView", vec![json!("App\\Models\\Post"), json!({ "line": 3 })]);
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
eventually("the plugin's command", || !mock.ran().is_empty()).await;
assert_eq!(mock.ran(), [json!(["App\\Models\\Post", { "line": 3 }])]);
assert!(mock.executed().is_empty(), "the server was not asked to execute it");
// A command in the server's `executeCommandProvider` still goes to the server.
ops::lsp::lsp_execute_command(&host, "main", doc, command("mock.own", vec![])).await.unwrap();
assert_eq!(mock.executed(), [json!("mock.own")]);
assert_eq!(mock.ran().len(), 1);
// A command nobody claims fails as before.
let err = ops::lsp::lsp_execute_command(&host, "main", doc, command("mock.unclaimed", vec![])).await.unwrap_err();
assert_eq!(err.kind, ide_core::error::ErrorKind::Unavailable, "{err:?}");
// Two plugins claim the same server and command: the first one loaded keeps it.
let second = variant(&tmp.path().join("second"), |m| m.replace(ID, SECOND));
plugins.install_from_dir(&second, &Consent::all()).unwrap();
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
eventually("the first plugin's command again", || mock.ran().len() == 2).await;
assert_eq!(plugins.info_of(SECOND).unwrap().stats.activations, 0, "the second plugin never ran");
// A claim counts only while the plugin holds the server's grant.
plugins.set_capability(ID, "lsp:mock", false).unwrap();
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
eventually("the second plugin's command", || mock.ran().len() == 3).await;
assert_eq!(plugins.info_of(SECOND).unwrap().stats.activations, 1);
plugins.set_capability(SECOND, "lsp:mock", false).unwrap();
let err = ops::lsp::lsp_execute_command(&host, "main", doc, lens).await.unwrap_err();
assert_eq!(err.kind, ide_core::error::ErrorKind::Unavailable, "{err:?}");
assert_eq!(mock.ran().len(), 3);
set_editor_providers(None);
server.abort();
}
+18 -14
Переглянути файл
@@ -70,10 +70,14 @@ async fn open(fixture: &str) -> Opened {
}
/// Polls `check` until it holds; fails with its last answer.
async fn until<T: std::fmt::Debug>(what: &str, timeout: Duration, mut check: impl FnMut() -> Result<(), T>) {
async fn until<T: std::fmt::Debug, F, Fut>(what: &str, timeout: Duration, mut check: F)
where
F: FnMut() -> Fut,
Fut: std::future::Future<Output = Result<(), T>>,
{
let deadline = Instant::now() + timeout;
loop {
match check() {
match check().await {
Ok(()) => return,
Err(last) if Instant::now() > deadline => panic!("{what}: timed out after {timeout:?}; last: {last:?}"),
Err(_) => tokio::time::sleep(Duration::from_millis(100)).await,
@@ -82,25 +86,25 @@ async fn until<T: std::fmt::Debug>(what: &str, timeout: Duration, mut check: imp
}
impl Opened {
fn files(&self, query: &str) -> Vec<String> {
let found = ops::nav::find_files(&self.host, WINDOW, query.into(), 20).unwrap();
async fn files(&self, query: &str) -> Vec<String> {
let found = ops::nav::find_files(&self.host, WINDOW, query.into(), 20).await.unwrap();
found.into_iter().map(|f| f.rel_path).collect()
}
fn symbols(&self, query: &str, filter: SymbolFilter) -> Vec<(String, String)> {
let found = ops::nav::find_symbols(&self.host, WINDOW, query.into(), filter, 20).unwrap();
async fn symbols(&self, query: &str, filter: SymbolFilter) -> Vec<(String, String)> {
let found = ops::nav::find_symbols(&self.host, WINDOW, query.into(), filter, 20).await.unwrap();
found.into_iter().map(|s| (s.name, s.rel_path)).collect()
}
fn has_symbol(&self, name: &str, file: &str, filter: SymbolFilter) -> Result<(), Vec<(String, String)>> {
let found = self.symbols(name, filter);
async fn has_symbol(&self, name: &str, file: &str, filter: SymbolFilter) -> Result<(), Vec<(String, String)>> {
let found = self.symbols(name, filter).await;
if found.iter().any(|(n, f)| n == name && f == file) { Ok(()) } else { Err(found) }
}
}
async fn smoke(f: Fixture) {
let p = open(f.dir).await;
until("indexing", Duration::from_secs(30), || {
until("indexing", Duration::from_secs(30), || async {
let s = ops::nav::index_status(&p.host, WINDOW).unwrap();
if !s.indexing && s.files > 0 && s.symbols > 0 { Ok(()) } else { Err(s) }
})
@@ -115,12 +119,12 @@ async fn smoke(f: Fixture) {
);
}
let files = p.files(f.file.0);
let files = p.files(f.file.0).await;
assert!(files.iter().any(|r| r == f.file.1), "{}: files for {:?}: {files:?}", f.dir, f.file.0);
if let Err(found) = p.has_symbol(f.class.0, f.class.1, SymbolFilter::Types) {
if let Err(found) = p.has_symbol(f.class.0, f.class.1, SymbolFilter::Types).await {
panic!("{}: Go to Class {:?}: {found:?}", f.dir, f.class.0);
}
if let Err(found) = p.has_symbol(f.symbol.0, f.symbol.1, SymbolFilter::All) {
if let Err(found) = p.has_symbol(f.symbol.0, f.symbol.1, SymbolFilter::All).await {
panic!("{}: Go to Symbol {:?}: {found:?}", f.dir, f.symbol.0);
}
@@ -130,8 +134,8 @@ async fn smoke(f: Fixture) {
until("a new file's class", Duration::from_secs(20), || p.has_symbol("FreshWidget", added, SymbolFilter::Types))
.await;
std::fs::remove_file(p.root.join(added)).unwrap();
until("a deleted file's class", Duration::from_secs(20), || {
let found = p.symbols("FreshWidget", SymbolFilter::Types);
until("a deleted file's class", Duration::from_secs(20), || async {
let found = p.symbols("FreshWidget", SymbolFilter::Types).await;
if found.is_empty() { Ok(()) } else { Err(found) }
})
.await;
+10 -2
Переглянути файл
@@ -646,8 +646,16 @@ impl IndexData {
}
}
pub(crate) fn record_of(&self, path: &Path) -> Option<FileRecord> {
self.get(path).map(|e| self.record(e))
/// Refreshes on-disk metadata of an unchanged-content file in place and
/// returns its persisted record.
pub(crate) fn refresh_metadata(&mut self, path: &Path, mtime: u64, size: u64, ignored: bool) -> Option<FileRecord> {
let slot = *self.by_path.get(path)?;
let e = self.files[slot as usize].as_mut()?;
e.mtime = mtime;
e.size = size;
e.ignored = ignored;
let e = self.files[slot as usize].as_ref()?;
Some(self.record(e))
}
/// The symbols of one file, in declaration order.
+5
Переглянути файл
@@ -323,6 +323,11 @@ impl ProjectIndex {
matching::symbols_named_within(&self.shared.data.read(), name, kind, roots, limit)
}
/// Symbols named exactly one of `names` whose file is inside `root`, at most `limit` per name.
pub fn symbols_named_any(&self, names: &[String], root: &Path, limit: usize) -> Vec<SymbolMatch> {
matching::symbols_named_any(&self.shared.data.read(), names, root, limit)
}
/// Incrementally re-indexes changed paths (called from the vfs watcher).
/// Cheap: the work is queued for the indexing thread.
pub fn update(&self, changed: &[PathBuf], removed: &[PathBuf]) {
+35
Переглянути файл
@@ -632,6 +632,41 @@ pub(crate) fn symbols_named_within(
out
}
/// Symbols named exactly one of `names` whose file is inside `root`, at most `limit` per
/// name, by path then position: one walk over the index for every name an agent reply shows.
pub(crate) fn symbols_named_any(data: &IndexData, names: &[String], root: &Path, limit: usize) -> Vec<SymbolMatch> {
let wanted: Vec<(u64, &str)> = names.iter().map(|name| (char_mask(name), name.as_str())).collect();
let syms = &data.syms;
let mut out: Vec<SymbolMatch> = data
.files
.iter()
.flatten()
.filter(|entry| entry.path.starts_with(root))
.flat_map(|entry| {
(entry.sym_start..entry.sym_start + entry.sym_len)
.filter(|&at| wanted.iter().any(|&(mask, name)| syms.mask(at) == mask && syms.name(at) == name))
.map(move |at| SymbolMatch {
name: syms.name(at).to_string(),
kind: syms.kind(at),
container: syms.container(at).map(str::to_owned),
path: entry.path.clone().into(),
rel_path: entry.rel.to_string(),
range: syms.range(at),
score: 0,
indices: Vec::new(),
})
})
.collect();
out.sort_by(|left, right| left.rel_path.cmp(&right.rel_path).then_with(|| left.range.cmp(&right.range)));
let mut kept: HashMap<String, usize> = HashMap::new();
out.retain(|symbol| {
let count = kept.entry(symbol.name.clone()).or_default();
*count += 1;
*count <= limit
});
out
}
#[cfg(test)]
mod tests {
use super::*;
+107 -2
Переглянути файл
@@ -549,6 +549,24 @@ fn symbols_named_within_keeps_out_of_root_matches_from_evicting_a_root() {
assert!(idx.symbols_named_within("Decoder", None, &[f.root.join("none")], 3).is_empty());
}
#[test]
fn symbols_named_any_answers_every_name_inside_the_root_in_one_walk() {
let fixture = Fixture::new(&[
("app/a.rs", "struct Config;\nfn load() {}\nfn load_all() {}\n"),
("app/b.rs", "fn load() {}\nfn load() {}\n"),
("other/c.rs", "struct Config;\n"),
]);
let idx = fixture.open();
let names = ["Config".to_string(), "load".to_string(), "missing".to_string()];
let found: Vec<(String, String)> = idx
.symbols_named_any(&names, &fixture.root.join("app"), 2)
.into_iter()
.map(|symbol| (symbol.name, symbol.rel_path))
.collect();
let expected = [("Config", "app/a.rs"), ("load", "app/a.rs"), ("load", "app/b.rs")];
assert_eq!(found, expected.map(|(name, path)| (name.to_string(), path.to_string())));
}
#[test]
fn content_roots_and_excludes_change_without_reopening() {
let fx = Fixture::new(&[("src/main.rs", "fn alpha() {}\n"), ("src/gen/out.rs", "fn generated() {}\n")]);
@@ -779,8 +797,13 @@ fn incremental_changes_refresh_the_warm_start_snapshot() {
let changed = f.write("src/a.rs", "fn renamed() {}\n");
idx.update(&[changed], &[]);
assert!(idx.wait_idle(WAIT));
std::thread::sleep(Duration::from_millis(150));
assert!(f.cache.join("index.snapshot").exists(), "a watcher update must regenerate the snapshot");
// The snapshot is written after a short delay, on the worker's next round.
let snapshot = f.cache.join("index.snapshot");
let deadline = std::time::Instant::now() + WAIT;
while !snapshot.exists() && std::time::Instant::now() < deadline {
std::thread::sleep(Duration::from_millis(20));
}
assert!(snapshot.exists(), "a watcher update must regenerate the snapshot");
}
#[test]
@@ -962,3 +985,85 @@ fn warm_start_sees_edits_deletions_and_renames_made_while_closed() {
assert_eq!(idx.status().files, 3);
assert_eq!(symbols(&idx, "zzzz", SymbolFilter::All), ["zzzz"]);
}
#[test]
fn queries_during_streaming_scan_do_not_deadlock() {
// More than `2 * SCAN_BATCH` (4,096) files so a scan both flushes mid-pass
// (`publish` -> `data.write()`) and fills the bounded parse channel while
// concurrent queries hold `data.read()` and dispatch onto Rayon.
const FILES: usize = 4_600;
let f = Fixture::new(&[]);
for m in 0..32 {
std::fs::create_dir_all(f.root.join(format!("mod{m}"))).unwrap();
}
for i in 0..FILES {
std::fs::write(
f.root.join(format!("mod{}/File{i}.rs", i % 32)),
format!("pub struct Type{i};\npub fn sym{i}() {{}}\n"),
)
.unwrap();
}
let (done_tx, done_rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
let languages = Arc::new(LanguageRegistry::load(None).unwrap());
let syntax = Arc::new(Syntax::new());
let stop = Arc::new(std::sync::atomic::AtomicBool::new(false));
let idx =
ProjectIndex::open(&f.root, &f.cache, Vec::new(), vec![], languages, syntax, Arc::new(NullSink)).unwrap();
let readers: Vec<_> = (0..4usize)
.map(|r| {
let idx = idx.clone();
let stop = stop.clone();
std::thread::spawn(move || {
let mut n = r;
while !stop.load(Ordering::Relaxed) {
match n % 3 {
0 => {
let _ = idx.find_files("File1", 20);
}
1 => {
let _ = idx.find_dirs("mod", 20);
}
_ => {
let _ = idx.find_symbols("sym1", SymbolFilter::All, 20);
}
}
n = n.wrapping_add(1);
}
})
})
.collect();
assert!(idx.wait_idle(WAIT), "initial streaming scan did not finish");
let parsed_before = idx.shared.parsed.load(Ordering::SeqCst);
assert_eq!(parsed_before, FILES);
// Touch every file without changing its contents so `parse_found` takes
// the `Extracted::Unchanged` path across multiple `SCAN_BATCH` flushes.
let bumped = std::fs::FileTimes::new().set_modified(std::time::SystemTime::now() + Duration::from_secs(10));
for i in 0..FILES {
let path = f.root.join(format!("mod{}/File{i}.rs", i % 32));
std::fs::File::options().write(true).open(path).unwrap().set_times(bumped).unwrap();
}
idx.shared.enqueue(Job::Rescan);
assert!(idx.wait_idle(WAIT), "rescan of unchanged-content files did not finish");
assert_eq!(idx.shared.parsed.load(Ordering::SeqCst), parsed_before, "unchanged content is not re-parsed");
assert_eq!(symbols(&idx, "sym4599", SymbolFilter::All), ["sym4599"]);
stop.store(true, Ordering::Relaxed);
for h in readers {
h.join().unwrap();
}
assert_eq!(idx.status().files, FILES as u32);
drop(idx);
let reopened = f.open();
assert_eq!(reopened.shared.parsed.load(Ordering::SeqCst), 0);
assert_eq!(symbols(&reopened, "sym4599", SymbolFilter::All), ["sym4599"]);
let _ = done_tx.send(());
});
done_rx.recv_timeout(Duration::from_secs(60)).expect("concurrent index queries deadlocked with streaming scan");
}
+146 -81
Переглянути файл
@@ -11,9 +11,21 @@ use rayon::prelude::*;
use std::collections::{HashMap, HashSet, VecDeque};
use std::io::Read;
use std::path::{Path, PathBuf};
use std::sync::LazyLock;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::{Duration, Instant, SystemTime};
/// Dedicated pool for background indexing and snapshot hydration: queries hold
/// `IndexData::read` while scanning on the global Rayon pool, so indexing work
/// (which may block on channel backpressure while the index thread waits for
/// `IndexData::write`) must never compete for the same workers.
static INDEX_POOL: LazyLock<rayon::ThreadPool> = LazyLock::new(|| {
rayon::ThreadPoolBuilder::new()
.thread_name(|i| format!("openidea-index-{i}"))
.build()
.expect("cannot build index thread pool")
});
/// Files larger than this are listed but not parsed for symbols.
pub const MAX_SYMBOL_FILE: u64 = 2 * 1024 * 1024;
const CHUNK: usize = 512;
@@ -254,17 +266,19 @@ impl Shared {
}
}
let build_started = Instant::now();
let entries: Vec<Option<(FileEntry, Vec<StoredSymbol>)>> = (0..snapshot.len())
.into_par_iter()
.map(|i| {
let path = root.join(snapshot.rel(i));
let meta = std::fs::symlink_metadata(&path).ok()?;
if !meta.is_file() || mtime_of(&meta) != snapshot.mtime(i) || meta.len() != snapshot.size(i) {
return None;
}
Some(snapshot.entry(i, root))
})
.collect();
let entries: Vec<Option<(FileEntry, Vec<StoredSymbol>)>> = INDEX_POOL.install(|| {
(0..snapshot.len())
.into_par_iter()
.map(|i| {
let path = root.join(snapshot.rel(i));
let meta = std::fs::symlink_metadata(&path).ok()?;
if !meta.is_file() || mtime_of(&meta) != snapshot.mtime(i) || meta.len() != snapshot.size(i) {
return None;
}
Some(snapshot.entry(i, root))
})
.collect()
});
let built = build_started.elapsed();
if entries.iter().any(Option::is_none) {
return false;
@@ -333,17 +347,19 @@ impl Shared {
let started = Instant::now();
match store.load_snapshot() {
Some(snapshot) => {
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = (0..snapshot.len())
.into_par_iter()
.filter_map(|i| {
let rel = snapshot.rel(i);
if !safe_rel(rel) {
return None;
}
let path = root.join(rel);
seen.contains(path.as_path()).then(|| snapshot.entry(i, &root))
})
.collect();
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = INDEX_POOL.install(|| {
(0..snapshot.len())
.into_par_iter()
.filter_map(|i| {
let rel = snapshot.rel(i);
if !safe_rel(rel) {
return None;
}
let path = root.join(rel);
seen.contains(path.as_path()).then(|| snapshot.entry(i, &root))
})
.collect()
});
let mut d = self.data.write();
let symbols = entries.iter().map(|(_, symbols)| symbols.len()).sum();
d.reserve(entries.len(), symbols, 0);
@@ -363,16 +379,18 @@ impl Shared {
Ok(records) => {
// Fallback for an index that changed since the snapshot: redb
// records are decoded one file at a time and filtered by the walk.
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = records
.into_par_iter()
.filter(|(rel, _)| {
safe_rel(rel) && {
let path = root.join(rel);
seen.contains(path.as_path())
}
})
.map(|(rel, rec)| FileEntry::new(root.join(&rel), rel, rec))
.collect();
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = INDEX_POOL.install(|| {
records
.into_par_iter()
.filter(|(rel, _)| {
safe_rel(rel) && {
let path = root.join(rel);
seen.contains(path.as_path())
}
})
.map(|(rel, rec)| FileEntry::new(root.join(&rel), rel, rec))
.collect()
});
let mut d = self.data.write();
let symbols = entries.iter().map(|(_, symbols)| symbols.len()).sum();
d.reserve(entries.len(), symbols, 0);
@@ -446,10 +464,11 @@ impl Shared {
}
let classify_started = Instant::now();
let seen: HashSet<&Path> = found.iter().map(|f| f.path.as_path()).collect();
let (todo, stale): (Vec<&Found>, Vec<PathBuf>) = {
let (todo, stale) = {
let d = self.data.read();
let todo = found.iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect();
let stale = d
let todo: Vec<(&Found, Option<ContentHash>)> =
found.iter().filter_map(|f| prev_hash_if_stale(&d, f).map(|h| (f, h))).collect();
let stale: Vec<PathBuf> = d
.paths()
.filter(|p| dirs.is_none_or(|dirs| dirs.iter().any(|dir| p.starts_with(dir))))
.filter(|p| !seen.contains(p.as_path()))
@@ -470,7 +489,7 @@ impl Shared {
let total = todo.len();
let mut laps = ChunkLaps::default();
{
// One streaming parallel pass: parse on the rayon pool without
// One streaming parallel pass: parse on `INDEX_POOL` without
// per-chunk joins (a straggler file at a join's tail idles every
// other core), while parsed files flow to this thread to be
// inserted and persisted in batches. `filter` moves into the
@@ -485,12 +504,14 @@ impl Shared {
let pass_started = Instant::now();
std::thread::scope(|scope| -> () {
scope.spawn(move || {
todo.par_iter().for_each(|f| {
if cancelled.load(Ordering::Relaxed) {
return;
}
let Some(out) = self.parse_found(f, &filter, false) else { return };
let _ = tx.send(out);
INDEX_POOL.install(|| {
todo.par_iter().for_each(|&(f, prev_hash)| {
if cancelled.load(Ordering::Relaxed) {
return;
}
let Some(out) = self.parse_found(f, prev_hash, &filter) else { return };
let _ = tx.send(out);
});
});
// `tx` drops here: the consumer's loop ends with the channel.
});
@@ -570,13 +591,13 @@ impl Shared {
}
/// Extracts records in parallel, then publishes them to memory and disk.
/// `force` re-parses files whose content is unchanged (their language changed).
fn index_files<'a>(&self, files: impl Iterator<Item = &'a Found>, force: bool) -> ChunkLaps {
fn index_files(&self, files: &[(Found, Option<ContentHash>)]) -> ChunkLaps {
let mut laps = ChunkLaps::default();
let files: Vec<&Found> = files.collect();
let filter = self.filter();
let started = Instant::now();
let extracted: Vec<ParsedFile> = files.par_iter().filter_map(|f| self.parse_found(f, &filter, force)).collect();
let extracted: Vec<ParsedFile> = INDEX_POOL.install(|| {
files.par_iter().filter_map(|(f, prev_hash)| self.parse_found(f, *prev_hash, &filter)).collect()
});
laps.extract = started.elapsed();
if extracted.is_empty() {
return laps;
@@ -585,49 +606,69 @@ impl Shared {
laps
}
/// Reads and parses one file (parallel-safe), serializing its record for
/// the cache alongside the parse. `None` when the file is outside the
/// scope or the scan was cancelled.
fn parse_found(&self, f: &Found, filter: &std::sync::Arc<PathFilter>, force: bool) -> Option<ParsedFile> {
/// Reads and parses one file on `INDEX_POOL` without locking `self.data`,
/// serializing new records for the cache alongside the parse. `None` when
/// the file is outside the scope or the scan was cancelled.
fn parse_found(
&self,
f: &Found,
prev_hash: Option<ContentHash>,
filter: &std::sync::Arc<PathFilter>,
) -> Option<ParsedFile> {
if self.is_cancelled() {
return None;
}
let rel = filter.rel(&f.path)?;
let prev_hash = if force { None } else { self.data.read().get(&f.path).map(|e| e.hash) };
let rec = match self.extract(f, prev_hash) {
Extracted::Unchanged => {
// Same content, new mtime: keep the symbols, refresh metadata.
let mut rec = self.data.read().record_of(&f.path)?;
rec.mtime = f.mtime;
rec.size = f.size;
rec.ignored = f.ignored;
rec
}
Extracted::New(rec) => rec,
};
let key = filter.store_key(&f.path);
let bytes = postcard::to_allocvec(&rec).ok();
Some(ParsedFile { rel, rec, key, bytes, path: f.path.clone() })
let outcome = match self.extract(f, prev_hash) {
Extracted::Unchanged => ParsedOutcome::Unchanged { mtime: f.mtime, size: f.size, ignored: f.ignored },
Extracted::New(rec) => {
let bytes = key.as_ref().and_then(|_| postcard::to_allocvec(&rec).ok());
ParsedOutcome::New { rec, bytes }
}
};
Some(ParsedFile { rel, key, outcome, path: f.path.clone() })
}
/// Inserts a parsed batch into the in-memory index and persists the records.
fn publish(&self, batch: impl Iterator<Item = ParsedFile>) -> ChunkLaps {
let mut laps = ChunkLaps::default();
let started = Instant::now();
let mut entries: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
let mut inserts: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
let mut refreshes: Vec<MetadataRefresh> = Vec::new();
let mut puts: Vec<(String, Vec<u8>)> = Vec::new();
for out in batch {
let ParsedFile { rel, rec, key, bytes, path } = out;
if let (Some(key), Some(bytes)) = (key, bytes) {
puts.push((key, bytes));
let ParsedFile { rel, key, outcome, path } = out;
match outcome {
ParsedOutcome::New { rec, bytes } => {
if let (Some(key), Some(bytes)) = (key, bytes) {
puts.push((key, bytes));
}
inserts.push(FileEntry::new(path, rel, rec));
}
ParsedOutcome::Unchanged { mtime, size, ignored } => {
refreshes.push(MetadataRefresh { path, key, mtime, size, ignored });
}
}
entries.push(FileEntry::new(path, rel, rec));
}
let mut refreshed_records: Vec<(String, FileRecord)> = Vec::new();
{
let mut d = self.data.write();
for (e, symbols) in entries {
for (e, symbols) in inserts {
d.insert(e, symbols);
}
for r in refreshes {
if let Some(rec) = d.refresh_metadata(&r.path, r.mtime, r.size, r.ignored)
&& let Some(key) = r.key
{
refreshed_records.push((key, rec));
}
}
}
for (key, rec) in refreshed_records {
if let Ok(bytes) = postcard::to_allocvec(&rec) {
puts.push((key, bytes));
}
}
laps.insert = started.elapsed();
let started = Instant::now();
@@ -818,9 +859,9 @@ impl Shared {
for (dir, wanted) in by_dir {
files.extend(filter.list_dir(&dir).into_iter().filter(|f| wanted.contains(&f.path)));
}
let files: Vec<Found> = {
let files: Vec<(Found, Option<ContentHash>)> = {
let d = self.data.read();
files.into_iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect()
files.into_iter().filter_map(|f| prev_hash_if_stale(&d, &f).map(|h| (f, h))).collect()
};
if !files.is_empty() {
touched = true;
@@ -828,17 +869,17 @@ impl Shared {
if self.is_cancelled() {
return;
}
self.index_files(chunk.iter(), false);
self.index_files(chunk);
}
}
for before in reparse {
let affected: Vec<Found> = {
let affected: Vec<(Found, Option<ContentHash>)> = {
let d = self.data.read();
d.paths()
.filter(|p| before.detect(p, None) != self.languages.detect(p, None))
.filter_map(|p| {
let e = d.get(p)?;
Some(Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored })
Some((Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored }, None))
})
.collect()
};
@@ -848,7 +889,7 @@ impl Shared {
if self.is_cancelled() {
return;
}
self.index_files(chunk.iter(), true);
self.index_files(chunk);
}
}
}
@@ -866,6 +907,18 @@ impl Shared {
}
}
type ContentHash = [u8; 32];
/// `Some(prev_hash)` when `f` is missing or stale in `d` (`None` inner hash when
/// the file must be parsed fresh); `None` when `d` is already current for `f`.
fn prev_hash_if_stale(d: &IndexData, f: &Found) -> Option<Option<ContentHash>> {
match d.get(&f.path) {
None => Some(None),
Some(e) if e.stale_for(f) => Some((!e.ignored).then_some(e.hash)),
Some(_) => None,
}
}
/// The first line, capped at 256 bytes (for shebang / `<?xml` detection).
fn first_line(text: &str) -> &str {
let line = text.lines().next().unwrap_or_default();
@@ -898,14 +951,26 @@ impl ChunkLaps {
}
}
/// One file parsed off the index thread: its record ready to publish, already
/// serialized for the cache (in parallel with the parse).
struct MetadataRefresh {
path: PathBuf,
key: Option<String>,
mtime: u64,
size: u64,
ignored: bool,
}
enum ParsedOutcome {
Unchanged { mtime: u64, size: u64, ignored: bool },
New { rec: FileRecord, bytes: Option<Vec<u8>> },
}
/// One file parsed off the index thread: its outcome ready to publish, with new
/// records already serialized for the cache in parallel with the parse.
struct ParsedFile {
rel: String,
rec: FileRecord,
/// Cache key and postcard bytes; `None` when outside the persisted root.
/// Cache key; `None` when outside the persisted root.
key: Option<String>,
bytes: Option<Vec<u8>>,
outcome: ParsedOutcome,
path: PathBuf,
}
+3
Переглянути файл
@@ -194,6 +194,9 @@ pub mod codes {
pub const METHOD_NOT_FOUND: i64 = -32601;
pub const INVALID_PARAMS: i64 = -32602;
pub const INTERNAL_ERROR: i64 = -32603;
/// LSP `RequestFailed`: the request was understood and could not be carried out; the
/// message says why.
pub const REQUEST_FAILED: i64 = -32803;
/// LSP `ServerCancelled`.
pub const SERVER_CANCELLED: i64 = -32802;
/// LSP `ContentModified`.
+8 -1
Переглянути файл
@@ -1,5 +1,6 @@
//! Pull Members Up / Push Members Down through the app-owned JDT extension
//! (`java/java-usages`). The server checks the move and computes the edit; the UI
//! (`java/java-usages`), or through Phoxite's own requests when the document's
//! server advertises them (`crate::phoxite`). The server checks the move and computes the edit; the UI
//! shows its problems and applies the edit itself.
use super::COMMAND_TIMEOUT;
use crate::types::{HierarchyChoice, HierarchyMembers, HierarchyRefactored, HierarchyRefactoring, RefactoringProblem};
@@ -75,6 +76,9 @@ impl LspManager {
kind: HierarchyRefactoring,
cancel: CancellationToken,
) -> IdeResult<HierarchyMembers> {
if let Some(phoxite) = self.phoxite_refactor_target(doc).await {
return self.phoxite_hierarchy_members(&phoxite, pos, kind, &cancel).await;
}
let (members, _, _) = self.hierarchy_command(doc, pos, kind, MEMBERS, &[], &cancel).await?;
Ok(members)
}
@@ -89,6 +93,9 @@ impl LspManager {
choices: Vec<HierarchyChoice>,
cancel: CancellationToken,
) -> IdeResult<HierarchyRefactored> {
if let Some(phoxite) = self.phoxite_refactor_target(doc).await {
return self.phoxite_hierarchy_refactor(&phoxite, pos, kind, target, &choices, &cancel).await;
}
let choices: Vec<Value> = choices.iter().map(|c| json!({ "id": c.id, "abstract": c.make_abstract })).collect();
let (refactored, _, t): (Refactored, _, _) =
self.hierarchy_command(doc, pos, kind, REFACTOR, &[json!(target), json!(choices)], &cancel).await?;
+1
Переглянути файл
@@ -26,6 +26,7 @@ mod launch;
mod library_source;
mod loading;
mod notebook;
mod phoxite;
mod plugin_requests;
mod pull;
mod scope;
+97
Переглянути файл
@@ -0,0 +1,97 @@
//! Pull Members Up / Push Members Down through Phoxite's own requests
//! (`phoxite/refactor/hierarchyMembers` and `phoxite/refactor/hierarchy`). A server says it
//! answers them with `experimental.phoxite.refactor` in its capabilities, so the server is
//! found by what it advertises, not by its name. As with the JDT extension, the server
//! checks the move and computes the edit; the UI shows its problems and applies the edit.
use crate::caps::ServerCaps;
use crate::types::{HierarchyChoice, HierarchyMembers, HierarchyRefactored, HierarchyRefactoring, RefactoringProblem};
use crate::{DocSnap, LspManager, Target, convert, rpc_err};
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, Pos};
use ide_jsonrpc::RpcError;
use serde::Deserialize;
use serde::de::DeserializeOwned;
use serde_json::{Value, json};
use std::time::Duration;
const MEMBERS: &str = "phoxite/refactor/hierarchyMembers";
const REFACTOR: &str = "phoxite/refactor/hierarchy";
/// The move is computed over the whole project.
const TIMEOUT: Duration = Duration::from_secs(120);
#[derive(Deserialize)]
struct Refactored {
problems: Vec<RefactoringProblem>,
edit: Option<lsp_types::WorkspaceEdit>,
}
/// Whether the server answers the `phoxite/refactor/*` requests.
fn refactors(caps: &ServerCaps) -> bool {
caps.raw.pointer("/experimental/phoxite/refactor").and_then(Value::as_bool) == Some(true)
}
impl LspManager {
/// The server of `doc` that answers `phoxite/refactor/*`, when one is attached.
pub(crate) async fn phoxite_refactor_target(&self, doc: DocId) -> Option<(DocSnap, Target)> {
let (snap, mut targets) = self.doc_targets(doc, "refactorings", refactors).await.ok()?;
Some((snap, targets.swap_remove(0)))
}
/// Sends one of the hierarchy requests. The server refuses a position it can't
/// refactor with LSP's `RequestFailed` and a message for the user: that is invalid
/// input, as the JDT extension's `refused` is. Any other error is the server failing.
async fn phoxite_hierarchy<R: DeserializeOwned>(
&self,
(snap, t): &(DocSnap, Target),
method: &str,
pos: Pos,
kind: HierarchyRefactoring,
extra: Value,
cancel: &CancellationToken,
) -> IdeResult<R> {
let mut params = json!({ "uri": snap.uri, "position": snap.position(t, pos), "kind": kind });
if let (Some(params), Value::Object(extra)) = (params.as_object_mut(), extra) {
params.extend(extra);
}
let request = t.run.peer.request::<Value, Value>(method, params, Some(cancel.clone()));
let answer = match tokio::time::timeout(TIMEOUT, request).await {
Ok(Ok(value)) => value,
Ok(Err(RpcError::Server { code, message, .. })) if code == ide_jsonrpc::codes::REQUEST_FAILED => {
return Err(IdeError::invalid(message));
}
Ok(Err(e)) => return Err(rpc_err(&t.server.name, method, e)),
Err(_) => return Err(rpc_err(&t.server.name, method, RpcError::Timeout)),
};
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
serde_json::from_value(answer).map_err(|e| rpc_err(&t.server.name, method, RpcError::Protocol(e.to_string())))
}
pub(crate) async fn phoxite_hierarchy_members(
&self,
target: &(DocSnap, Target),
pos: Pos,
kind: HierarchyRefactoring,
cancel: &CancellationToken,
) -> IdeResult<HierarchyMembers> {
self.phoxite_hierarchy(target, MEMBERS, pos, kind, Value::Null, cancel).await
}
pub(crate) async fn phoxite_hierarchy_refactor(
&self,
target: &(DocSnap, Target),
pos: Pos,
kind: HierarchyRefactoring,
destination: Option<String>,
choices: &[HierarchyChoice],
cancel: &CancellationToken,
) -> IdeResult<HierarchyRefactored> {
let extra = json!({ "target": destination, "choices": choices });
let refactored: Refactored = self.phoxite_hierarchy(target, REFACTOR, pos, kind, extra, cancel).await?;
let conv = self.conv(target.1.enc());
Ok(HierarchyRefactored {
problems: refactored.problems,
edit: refactored.edit.map(|e| convert::workspace_edit(&conv, e)),
})
}
}
+10
Переглянути файл
@@ -57,6 +57,16 @@ impl LspManager {
Ok(running.swap_remove(at))
}
/// Names (in the language definition) of the servers attached to `doc`, or of every
/// server of the project when the document is not open; only `server`'s when given.
pub fn server_names(&self, doc: ide_core::DocId, server: Option<ide_core::ServerId>) -> Vec<String> {
let servers = match self.snapshot(doc) {
Ok(snap) => snap.servers,
Err(_) => self.servers.lock().clone(),
};
servers.iter().filter(|s| server.is_none_or(|id| s.id == id)).map(|s| s.name.clone()).collect()
}
/// Sends a plugin's request to the running server named `server` (its name in the
/// language definition) and returns the result. `not_found` when it is not running,
/// `invalid` for a method that is not the server's own.
+88
Переглянути файл
@@ -7429,3 +7429,91 @@ async fn a_plugin_request_reaches_only_a_running_servers_own_methods() {
let e = h.mgr.server_request(&h.root, "main", "mock/routes", None, &cancel, timeout).await.unwrap_err();
assert_eq!(e.kind, ide_core::error::ErrorKind::Cancelled);
}
/// A server that advertises `experimental.phoxite.refactor` gets Pull Members Up / Push
/// Members Down as its own `phoxite/refactor/*` requests, whatever its name.
#[tokio::test(flavor = "multi_thread")]
async fn hierarchy_refactorings_use_phoxites_requests_when_the_server_advertises_them() {
let mut caps = incremental_caps();
caps["experimental"] = json!({ "phoxite": { "laravel": true, "refactor": true } });
let h = harness_for("php", "php", &[("any-name", caps)], &[]);
let s = h.launcher.state("any-name");
*s.responder.lock() = Some(Arc::new(|_, method, params| {
let uri = params["uri"].clone();
match (method, params["position"]["line"].as_u64()) {
("phoxite/refactor/hierarchyMembers", Some(0)) => Some(json!({
"className": "Dog",
"targets": [{ "id": "App\\Animal", "name": "Animal", "qualifiedName": "App\\Animal", "interface": false }],
"members": [
{ "id": "method:bark", "label": "bark(): string", "kind": "method", "selected": true, "abstractable": true },
{ "id": "constant:LEGS", "label": "LEGS", "kind": "field", "selected": false, "abstractable": false },
],
})),
("phoxite/refactor/hierarchy", _) => Some(json!({
"problems": [{ "severity": "warning", "message": "bark() uses $tail, which stays in Dog" }],
"edit": { "changes": { uri.as_str().unwrap(): [
{ "range": { "start": { "line": 0, "character": 0 }, "end": { "line": 0, "character": 5 } }, "newText": "<?php" }
] } },
})),
_ => None,
}
}));
let text =
format!("<?php class Dog extends Animal {{ function bark(): string {{ return ''; }} }}{}", "\n".repeat(9));
let (doc, path) = h.open("Dog.php", &text);
h.wait_status("any-name", ServerStatus::Ready).await;
eventually(|| s.docs.lock().len() == 1).await;
let info =
h.mgr.hierarchy_members(doc, Pos::new(0, 40), HierarchyRefactoring::PullUp, Default::default()).await.unwrap();
assert_eq!((info.class_name.as_str(), info.targets[0].qualified_name.as_str()), ("Dog", "App\\Animal"));
assert!(info.members[0].selected && info.members[0].abstractable);
assert_eq!(
info.members.iter().map(|m| m.kind).collect::<Vec<_>>(),
[HierarchyMemberKind::Method, HierarchyMemberKind::Field]
);
assert_eq!(
s.requested("phoxite/refactor/hierarchyMembers"),
[json!({ "uri": uri_of(&path), "position": { "line": 0, "character": 40 }, "kind": "pullUp" })]
);
let choices = vec![HierarchyChoice { id: "method:bark".into(), make_abstract: true }];
let done = h
.mgr
.hierarchy_refactor(
doc,
Pos::new(0, 40),
HierarchyRefactoring::PullUp,
Some("App\\Animal".into()),
choices,
Default::default(),
)
.await
.unwrap();
assert_eq!(done.problems[0].severity, ProblemSeverity::Warning);
let edit = done.edit.unwrap();
assert!(matches!(&edit.files[..], [FileEdit::Edit { path: p, edits, .. }] if p == &path && edits.len() == 1));
assert_eq!(
s.requested("phoxite/refactor/hierarchy"),
[json!({
"uri": uri_of(&path), "position": { "line": 0, "character": 40 }, "kind": "pullUp",
"target": "App\\Animal", "choices": [{ "id": "method:bark", "makeAbstract": true }],
})]
);
assert!(s.requested("workspace/executeCommand").is_empty(), "not the JDT extension's commands");
// The server refuses a position with `RequestFailed` and a message for the user.
let refusal = (-32803, "'Dog' has no parent class or interface in the project".to_owned());
s.errors.lock().insert("phoxite/refactor/hierarchyMembers".into(), refusal);
let refused = h.mgr.hierarchy_members(doc, Pos::new(9, 0), HierarchyRefactoring::PullUp, Default::default()).await;
let e = refused.unwrap_err();
assert_eq!(e.kind, ide_core::error::ErrorKind::InvalidInput);
assert_eq!(e.message, "'Dog' has no parent class or interface in the project");
// Any other error is the server failing, not a reason to show as the user's mistake.
s.errors.lock().insert("phoxite/refactor/hierarchyMembers".into(), (-32603, "index out of bounds".to_owned()));
let failed = h.mgr.hierarchy_members(doc, Pos::new(9, 0), HierarchyRefactoring::PullUp, Default::default()).await;
let e = failed.unwrap_err();
assert_eq!(e.kind, ide_core::error::ErrorKind::Protocol);
assert_eq!(e.message, "any-name: index out of bounds");
}
+79
Переглянути файл
@@ -1022,3 +1022,82 @@ async fn basedpyright_and_ruff_serve_notebook_cells() {
mgr.close_notebook(&path);
tokio::time::timeout(Duration::from_secs(10), mgr.shutdown_all()).await.unwrap();
}
/// Pull Members Up through Phoxite's own requests: the real server moves a method to
/// the parent class in another file.
#[tokio::test(flavor = "multi_thread")]
#[ignore = "requires phoxite-lsp on PATH (or OPENIDEA_TEST_PHOXITE_LSP)"]
async fn phoxite_pulls_a_member_up_end_to_end() {
use ide_core::FileEdit;
use ide_lsp::types::{HierarchyChoice, HierarchyRefactoring};
let dir = tempfile::tempdir().unwrap();
let root = dir.path().canonicalize().unwrap();
std::fs::create_dir(root.join("src")).unwrap();
std::fs::write(root.join("composer.json"), r#"{"autoload":{"psr-4":{"App\\":"src/"}}}"#).unwrap();
let animal = root.join("src").join("Animal.php");
std::fs::write(&animal, "<?php\n\nnamespace App;\n\nclass Animal\n{\n}\n").unwrap();
let path = root.join("src").join("Dog.php");
let source = "<?php\n\nnamespace App;\n\nclass Dog extends Animal\n{\n public function bark(): string\n {\n return 'woof';\n }\n}\n";
std::fs::write(&path, source).unwrap();
let mut php = LanguageRegistry::load(None).unwrap().get(&LanguageId::new("php")).unwrap();
php.language_servers.retain(|s| s.name == "phoxite");
assert_eq!(php.language_servers.len(), 1);
php.language_servers[0].fallback = false;
if let Ok(bin) = std::env::var("OPENIDEA_TEST_PHOXITE_LSP") {
php.language_servers[0].command = bin;
}
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![php]));
let doc = DocId::next();
mgr.did_open(doc, &path, &LanguageId::new("php"), 1, source);
retry("phoxite ready", Duration::from_secs(30), || {
let status = last_status(&events, "phoxite");
if let Some((ServerStatus::Crashed | ServerStatus::Missing | ServerStatus::Misconfigured, msg)) = &status {
panic!("phoxite failed: {msg:?}");
}
async move { matches!(status, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }
})
.await;
// On `bark`; the parent is known once the project is indexed.
let at = Pos::new(6, 22);
let info = retry("the movable members", Duration::from_secs(60), || {
let mgr = mgr.clone();
async move { mgr.hierarchy_members(doc, at, HierarchyRefactoring::PullUp, Default::default()).await.ok() }
})
.await;
assert_eq!(info.class_name, "Dog");
assert_eq!(
info.targets.iter().map(|t| t.qualified_name.trim_start_matches('\\')).collect::<Vec<_>>(),
["App\\Animal"]
);
let bark = info.members.iter().find(|m| m.label.starts_with("bark")).expect("bark is movable");
assert!(bark.selected, "{bark:?}");
let choices = vec![HierarchyChoice { id: bark.id.clone(), make_abstract: false }];
let done = mgr
.hierarchy_refactor(
doc,
at,
HierarchyRefactoring::PullUp,
Some(info.targets[0].id.clone()),
choices,
Default::default(),
)
.await
.unwrap();
let edit = done.edit.expect("an edit");
let mut edited: Vec<_> = edit
.files
.iter()
.filter_map(|f| match f {
FileEdit::Edit { path, edits, .. } if !edits.is_empty() => path.0.file_name()?.to_str().map(str::to_owned),
_ => None,
})
.collect();
edited.sort();
assert_eq!(edited, ["Animal.php", "Dog.php"], "the method leaves Dog and arrives in Animal");
// Outside any class the server refuses with `RequestFailed`: the reason reaches the user.
let refused = mgr.hierarchy_members(doc, Pos::new(0, 0), HierarchyRefactoring::PullUp, Default::default()).await;
let refused = refused.unwrap_err();
assert_eq!(refused.kind, ide_core::error::ErrorKind::InvalidInput, "{refused:?}");
assert!(!refused.message.is_empty() && !refused.message.starts_with("phoxite:"), "{refused:?}");
mgr.shutdown_all().await;
}
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
4788f82b35966e155dbf51af520acb2d5e7773ddf9f36f4239b9bd51d51b0fb3
6a36bd56db7148032c1fe101bec8c38e326528b1de1ee26b5d7c5b9dd80b3e94
+10
Переглянути файл
@@ -22,3 +22,13 @@ title = "Send a method of LSP itself"
[[contributes.commands]]
id = "ungranted"
title = "Ask a server the manifest does not name"
[[contributes.commands]]
id = "ran"
title = "Run a command the mock server left to the client"
# The mock server's code lenses carry `mock.modelView` without executing it.
[[contributes.serverCommands]]
server = "mock"
command = "mock.modelView"
run = "ran"
+2
Переглянути файл
@@ -10,6 +10,8 @@ impl Plugin for LspRequests {
"request" => project.language_server_request("mock", "mock/routes", arg).map(Some),
"notify" => project.language_server_notify("mock", "mock/changed", arg).map(|()| None),
"standard" => project.language_server_request("mock", "textDocument/hover", arg).map(Some),
// Shows the server what arrived: the arguments of the command it handed to the client.
"ran" => project.language_server_notify("mock", "mock/ran", arg).map(|()| None),
"ungranted" => project.language_server_request("other", "other/status", arg).map(Some),
_ => Err(Error::NotFound(id.into())),
}
+41 -2
Переглянути файл
@@ -338,6 +338,15 @@ pub fn env_wrapper(bin_dir: &Path, command: &str, target: &Path, env: &[(&str, &
}
pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResult<PathBuf> {
link_executable_with_runtime(bin_dir, command, target, None)
}
pub fn link_executable_with_runtime(
bin_dir: &Path,
command: &str,
target: &Path,
runtime: Option<&str>,
) -> IdeResult<PathBuf> {
fs::create_dir_all(bin_dir)?;
#[cfg(unix)]
{
@@ -347,7 +356,8 @@ pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResul
}
let quoted = target.to_string_lossy().replace('\'', r"'\''");
// A Node script without a shebang (e.g. js-debug's dapDebugServer.js) runs through `node`.
let runner = if target.extension().is_some_and(|e| e == "js") { "node " } else { "" };
let runner = runtime.or_else(|| target.extension().is_some_and(|e| e == "js").then_some("node"));
let runner = runner.map(|r| format!("{r} ")).unwrap_or_default();
fs::write(&link, format!("#!/bin/sh\nexec {runner}'{quoted}' \"$@\"\n"))?;
make_executable(&link)?;
make_executable(target)?;
@@ -356,7 +366,8 @@ pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResul
#[cfg(not(unix))]
{
let link = bin_dir.join(format!("{command}.cmd"));
let runner = if target.extension().is_some_and(|e| e == "js") { "node " } else { "" };
let runner = runtime.or_else(|| target.extension().is_some_and(|e| e == "js").then_some("node"));
let runner = runner.map(|r| format!("{r} ")).unwrap_or_default();
fs::write(&link, format!("@echo off\r\n{runner}\"{}\" %*\r\n", cmd_path(bin_dir, target)))?;
Ok(link)
}
@@ -510,6 +521,34 @@ mod tests {
assert!(dest.join("ok.txt").exists());
}
#[test]
fn unity_vsix_wrapper_preserves_managed_assemblies_and_uses_mono_on_unix() {
let tmp = tempfile::tempdir().unwrap();
let archive = tmp.path().join("unity.vsix");
zip_file(
&archive,
&[
("extension/bin/UnityDebug.exe", b"adapter", 0o644),
("extension/bin/UnityDebug.exe.config", b"runtime config", 0o644),
("extension/bin/Mono.Debugger.Soft.dll", b"dependency", 0o644),
],
);
let dest = tmp.path().join("install with spaces");
extract(&archive, ArchiveKind::Zip, &dest, "unity-debug", &CancellationToken::new()).unwrap();
let target = locate(&dest, &["UnityDebug.exe".into()]).unwrap();
let wrapper =
link_executable_with_runtime(&dest.join("bin"), "unity-debug", &target, cfg!(unix).then_some("mono"))
.unwrap();
let script = fs::read_to_string(wrapper).unwrap();
assert!(script.contains(&*target.to_string_lossy()));
#[cfg(unix)]
assert!(script.contains("exec mono '") && script.contains("\"$@\""));
#[cfg(windows)]
assert!(script.contains("\" %*") && !script.contains("mono "));
assert_eq!(fs::read(target.with_extension("exe.config")).unwrap(), b"runtime config");
assert_eq!(fs::read(target.parent().unwrap().join("Mono.Debugger.Soft.dll")).unwrap(), b"dependency");
}
#[test]
fn zip_symlinks_are_confined_to_the_destination() {
for target in ["../outside", "/tmp/outside", "a/../../outside"] {
+13 -1
Переглянути файл
@@ -1296,6 +1296,14 @@ impl Tools {
cancel: &CancellationToken,
) -> IdeResult<sources::Download> {
match source {
ReleaseSource::Fixed { version, url, sha256 } => Ok(sources::Download {
version: version.into(),
name: url.rsplit('/').next().unwrap_or("download").into(),
url: url.into(),
size: None,
sha256: Some(sha256.into()),
checksum_url: None,
}),
ReleaseSource::GitHub { repo } => match http.get_text(&sources::github_latest_url(repo), cancel) {
Ok(json) => sources::github_pick(&json, assets, self.platform),
Err(e) if e.kind == ErrorKind::Cancelled => Err(e),
@@ -1442,7 +1450,11 @@ impl Tools {
} else {
archive::make_executable(&target)?;
if self.exe_in(&bin, main).as_deref() != Some(target.as_path()) {
archive::link_executable(&bin, main, &target)?;
if spec.name == "unity-debug" && cfg!(unix) {
archive::link_executable_with_runtime(&bin, main, &target, Some("mono"))?;
} else {
archive::link_executable(&bin, main, &target)?;
}
}
}
self.write_manifest(spec.name, &Manifest { version: Some(dl.version.clone()), source: Some(dl.url.clone()) })
+28
Переглянути файл
@@ -20,6 +20,8 @@ pub enum ToolKind {
/// Where release archives come from.
#[derive(Clone, Copy, Debug)]
pub enum ReleaseSource {
/// One pinned archive, verified against its SHA-256 before extraction.
Fixed { version: &'static str, url: &'static str, sha256: &'static str },
/// Latest GitHub release of `owner/repo`; assets plus links in the release notes.
GitHub { repo: &'static str },
/// `api.releases.hashicorp.com` product.
@@ -80,6 +82,7 @@ impl Method {
Method::Release { source: ReleaseSource::EclipseJdtls, .. } => "Eclipse download",
Method::Release { source: ReleaseSource::OpenVsx { .. }, .. } => "Open VSX",
Method::Release { source: ReleaseSource::MavenCentral { .. }, .. } => "Maven Central",
Method::Release { source: ReleaseSource::Fixed { .. }, .. } => "Verified download",
Method::Release { .. } => "GitHub release",
}
}
@@ -131,6 +134,29 @@ const fn ver(cmd: &'static str) -> Option<(&'static str, &'static [&'static str]
pub const TYPESCRIPT: &str = "typescript@6";
pub static TOOLS: &[ToolSpec] = &[
ToolSpec {
name: "unity-debug",
display: "Unity Debugger",
kind: Debugger,
commands: &["unity-debug"],
method: Method::Release {
source: ReleaseSource::Fixed {
version: "3.0.1",
url: "https://github.com/Unity-Technologies/vscode-unity-debug/releases/download/Version-3.0.1/unity-debug-3.0.1.vsix",
sha256: "4fa00660e0b52b0413726f80962e7d3d6efd41ac6cfd4df39520cae4a8ba5bd0",
},
assets: &[any_arch(Mac, "*.vsix"), any_arch(Linux, "*.vsix"), any_arch(Windows, "*.vsix")],
locate: &["UnityDebug.exe"],
},
fallback: None,
version: V,
homepage: "https://github.com/Unity-Technologies/vscode-unity-debug",
needs: if cfg!(windows) {
&[]
} else {
&[("mono", "Mono is required to run the Unity debugger (https://www.mono-project.com)")]
},
},
ToolSpec {
name: "prettier",
display: "Prettier",
@@ -1164,6 +1190,8 @@ mod tests {
fn registry_names_match_language_configs() {
let langs = ide_language::LanguageRegistry::load(None).unwrap().all();
let mut known = std::collections::HashSet::new();
// The Unity debugger comes with Unity projects, apart from the C# debugger.
known.insert(("unity-debug".to_owned(), "unity-debug".to_owned()));
for l in &langs {
for s in &l.language_servers {
known.insert((s.name.clone(), s.command.clone()));
+18
Переглянути файл
@@ -49,6 +49,24 @@ fn find<'a>(list: &'a [ToolInfo], name: &str) -> &'a ToolInfo {
list.iter().find(|t| t.name == name).unwrap_or_else(|| panic!("{name} not listed"))
}
#[test]
fn unity_adapter_download_is_pinned_and_checksum_verified() {
let env = Env::new();
let tools = env.tools();
let spec = registry::find("unity-debug").unwrap();
let Method::Release { source, assets, locate } = spec.method else { panic!("expected release") };
// A fixed release resolves without a network request.
let curl = env.sys.join(if cfg!(windows) { "curl.exe" } else { "curl" });
fs::write(&curl, b"unused").unwrap();
archive::make_executable(&curl).unwrap();
let http = Http::new(env.sys.as_os_str()).unwrap();
let download = tools.resolve_release(&http, source, assets, &CancellationToken::new()).unwrap();
assert_eq!(download.version, "3.0.1");
assert!(download.url.starts_with("https://github.com/Unity-Technologies/vscode-unity-debug/releases/download/"));
assert_eq!(download.sha256.as_deref(), Some("4fa00660e0b52b0413726f80962e7d3d6efd41ac6cfd4df39520cae4a8ba5bd0"));
assert_eq!(locate, &["UnityDebug.exe"]);
}
#[test]
fn bundled_lombok_replaces_legacy_installs_on_every_platform_without_downloads() {
for os in [Os::Mac, Os::Linux, Os::Windows] {
+15
Переглянути файл
@@ -33,6 +33,7 @@ pub(crate) fn virtual_env_marker(dir: &Path) -> Option<&'static str> {
/// Build files whose changes can change the detected roots.
pub(crate) const BUILD_FILES: &[&str] = &[
"pom.xml",
".classpath",
"build.gradle",
"build.gradle.kts",
"settings.gradle",
@@ -238,6 +239,20 @@ fn module_roots(root: &Path, rel: &str, files: &[String], out: &mut Vec<SourceFo
}
}
// An Eclipse project without Maven or Gradle: its `.classpath` is the source model.
if has(".classpath")
&& !has("pom.xml")
&& !GRADLE_FILES.iter().any(|f| has(f))
&& let Some(cp) = super::eclipse::classpath(&dir)
{
for (sub, test) in &cp.sources {
add(sub, if *test { RootKind::Test } else { RootKind::Source }, ".classpath");
}
if let Some(output) = &cp.output {
add(output, RootKind::Excluded, ".classpath");
}
}
// Before `package.json`: a Laravel app's `tests/` is the PHP test root.
if has("composer.json")
&& let Ok(text) = std::fs::read_to_string(dir.join("composer.json"))
+193
Переглянути файл
@@ -0,0 +1,193 @@
//! Eclipse projects without Maven or Gradle: `.classpath` names the source folders (tests
//! by their `test` attribute), the output folder and the library jars; a Dynamic Web
//! Project's `.settings/org.eclipse.wst.common.component` names the web content folder.
use std::path::Path;
/// What `.classpath` declares, with project-relative `/`-separated paths.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct EclipseClasspath {
/// Source folders and whether they hold tests.
pub sources: Vec<(String, bool)>,
pub output: Option<String>,
/// Library jars or class folders (`kind="lib"`), project-relative or absolute.
pub libraries: Vec<String>,
}
/// The value of `name="…"` in a tag's text.
fn attribute(tag: &str, name: &str) -> Option<String> {
let mut rest = tag;
while let Some(at) = rest.find(name) {
let before = rest[..at].chars().last();
let after = &rest[at + name.len()..];
rest = after;
if before.is_some_and(|c| !c.is_whitespace()) {
continue;
}
let Some(after) = after.trim_start().strip_prefix('=') else { continue };
let after = after.trim_start();
let quote = after.chars().next().filter(|c| *c == '"' || *c == '\'')?;
let value = &after[1..];
let end = value.find(quote)?;
return Some(unescape(&value[..end]));
}
None
}
fn unescape(value: &str) -> String {
value.replace("&quot;", "\"").replace("&apos;", "'").replace("&lt;", "<").replace("&gt;", ">").replace("&amp;", "&")
}
/// Each element `<name …>…</name>` or `<name …/>` as (opening tag, inner text).
fn elements<'a>(text: &'a str, name: &str) -> Vec<(&'a str, &'a str)> {
let open = format!("<{name}");
let close = format!("</{name}>");
let mut out = Vec::new();
let mut rest = text;
while let Some(at) = rest.find(&open) {
let from = &rest[at..];
// `<classpathentry` must not match `<classpathentryX`.
if !from[open.len()..].starts_with(|c: char| c.is_whitespace() || c == '/' || c == '>') {
rest = &from[open.len()..];
continue;
}
let Some(end) = from.find('>') else { break };
let tag = &from[..=end];
if tag.ends_with("/>") {
out.push((tag, ""));
rest = &from[end + 1..];
} else {
let body = &from[end + 1..];
let stop = body.find(&close).unwrap_or(body.len());
out.push((tag, &body[..stop]));
rest = &body[stop..];
}
}
out
}
fn clean(path: &str) -> String {
let p = path.trim().replace('\\', "/");
let p = p.trim_start_matches("./").trim_end_matches('/');
p.to_owned()
}
pub fn parse_classpath(text: &str) -> EclipseClasspath {
let mut out = EclipseClasspath::default();
for (tag, body) in elements(text, "classpathentry") {
let (Some(kind), Some(path)) = (attribute(tag, "kind"), attribute(tag, "path")) else { continue };
let path = clean(&path);
match kind.as_str() {
// `/OtherProject` is a project reference, not a folder of this one.
"src" if !path.starts_with('/') && !path.is_empty() => {
let test = elements(body, "attribute").iter().any(|(a, _)| {
attribute(a, "name").as_deref() == Some("test") && attribute(a, "value").as_deref() == Some("true")
});
out.sources.push((path, test));
}
"output" if !path.is_empty() => out.output = Some(path),
"lib" if !path.is_empty() => out.libraries.push(path),
_ => {}
}
}
out
}
/// The project's `.classpath`, unless a Maven or Gradle build owns its model.
pub fn classpath(dir: &Path) -> Option<EclipseClasspath> {
if ["pom.xml", "build.gradle", "build.gradle.kts"].iter().any(|f| dir.join(f).is_file()) {
return None;
}
std::fs::read_to_string(dir.join(".classpath")).ok().map(|t| parse_classpath(&t))
}
/// The web content folder of a web project: the `wb-resource` deployed at `/`, else a
/// conventional `WebContent` / `WebRoot` / `web` / `src/main/webapp` holding `WEB-INF/web.xml`.
pub fn web_root(dir: &Path) -> Option<String> {
if let Ok(text) = std::fs::read_to_string(dir.join(".settings/org.eclipse.wst.common.component")) {
for (tag, _) in elements(&text, "wb-resource") {
if attribute(tag, "deploy-path").as_deref() == Some("/")
&& let Some(source) = attribute(tag, "source-path")
{
let source = clean(source.trim_start_matches('/'));
if dir.join(&source).is_dir() {
return Some(source);
}
}
}
}
["WebContent", "WebRoot", "web", "src/main/webapp"]
.into_iter()
.find(|d| dir.join(d).join("WEB-INF/web.xml").is_file())
.map(str::to_owned)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reads_sources_tests_output_and_libraries() {
let cp = parse_classpath(
r#"<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" output="bin/test" path="test">
<attributes>
<attribute name="test" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="src" path="/OtherProject"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry kind="lib" path="WebContent/WEB-INF/lib/commons-lang.jar"/>
<classpathentry kind='lib' path='lib\mail.jar' sourcepath="lib/mail-src.zip"/>
<classpathentry kind="output" path="build/classes"/>
</classpath>"#,
);
assert_eq!(cp.sources, [("src".to_owned(), false), ("test".to_owned(), true)]);
assert_eq!(cp.output.as_deref(), Some("build/classes"));
assert_eq!(cp.libraries, ["WebContent/WEB-INF/lib/commons-lang.jar", "lib/mail.jar"]);
}
#[test]
fn finds_the_web_content_folder() {
let dir = tempfile::tempdir().unwrap();
std::fs::create_dir_all(dir.path().join("site/WEB-INF")).unwrap();
std::fs::create_dir_all(dir.path().join(".settings")).unwrap();
std::fs::write(
dir.path().join(".settings/org.eclipse.wst.common.component"),
r#"<project-modules><wb-module deploy-name="shop">
<wb-resource deploy-path="/WEB-INF/classes" source-path="/src"/>
<wb-resource deploy-path="/" source-path="/site" tag="defaultRootSource"/>
</wb-module></project-modules>"#,
)
.unwrap();
assert_eq!(web_root(dir.path()).as_deref(), Some("site"));
let plain = tempfile::tempdir().unwrap();
std::fs::create_dir_all(plain.path().join("WebRoot/WEB-INF")).unwrap();
assert_eq!(web_root(plain.path()), None);
std::fs::write(plain.path().join("WebRoot/WEB-INF/web.xml"), "<web-app/>").unwrap();
assert_eq!(web_root(plain.path()).as_deref(), Some("WebRoot"));
}
#[test]
fn detects_the_roots_of_an_eclipse_project() {
use super::super::{RootKind, detect};
let dir = tempfile::tempdir().unwrap();
for d in ["src", "test", "bin"] {
std::fs::create_dir_all(dir.path().join(d)).unwrap();
}
std::fs::write(
dir.path().join(".classpath"),
r#"<classpath><classpathentry kind="src" path="src"/><classpathentry kind="src" path="test"><attributes><attribute name="test" value="true"/></attributes></classpathentry><classpathentry kind="output" path="bin"/></classpath>"#,
)
.unwrap();
let roots: Vec<(String, RootKind)> = detect(dir.path()).into_iter().map(|r| (r.path, r.kind)).collect();
assert_eq!(
roots,
[("bin".into(), RootKind::Excluded), ("src".into(), RootKind::Source), ("test".into(), RootKind::Test)]
);
// A Maven build owns the model even with a stale `.classpath` next to it.
std::fs::write(dir.path().join("pom.xml"), "<project/>").unwrap();
assert!(detect(dir.path()).iter().all(|r| r.detected_from.as_deref() != Some(".classpath")));
}
}
+1
Переглянути файл
@@ -6,6 +6,7 @@
//! project-relative and `/`-separated; `""` is the project root itself.
mod detect;
pub mod eclipse;
pub(crate) use detect::{BUILD_FILES, virtual_env_marker};
mod gradle;
mod java;
+21 -1
Переглянути файл
@@ -30,12 +30,14 @@ pub enum SettingsScope {
/// Settings a project's own file can't hold: the IDE's MCP server, imported color schemes, and
/// what agents may do without asking (commands run without asking, the modes new tasks start in,
/// whether new tasks ask for approvals).
const USER_ONLY: [&[&str]; 5] = [
const USER_ONLY: [&[&str]; 6] = [
&["mcpServer"],
&["editor", "customSchemes"],
&["agentSecurity", "allowedCommands"],
&["agents", "defaults"],
&["agents", "newTaskApprovals"],
// OS notification centre: machine-local; projects must not enable/disable.
&["notifications", "systemNotifications"],
];
/// The [`USER_ONLY`] setting that writing `value` at `key` would set, as a dotted key.
@@ -1219,4 +1221,22 @@ mod tests {
std::fs::write(project.join(".openidea/settings.toml"), "[agents]\nnewTaskApprovals = \"bypass\"\n").unwrap();
assert_eq!(settings.reload().agents.new_task_approvals, NewTaskApprovals::Ask);
}
#[test]
fn system_notifications_are_a_user_setting() {
let tmp = tempfile::tempdir().unwrap();
let config = tmp.path().join("config");
let project = tmp.path().join("project");
std::fs::create_dir_all(project.join(".openidea")).unwrap();
std::fs::write(project.join(".openidea/settings.toml"), "[notifications]\nsystemNotifications = false\n")
.unwrap();
let settings = SettingsStore::load(&config, Some(&project));
assert!(settings.effective().notifications.system_notifications);
assert!(settings.set(SettingsScope::Project, "notifications.systemNotifications", json!(false)).is_err());
let s = settings.set(SettingsScope::Global, "notifications.systemNotifications", json!(false)).unwrap();
assert!(!s.notifications.system_notifications);
std::fs::write(project.join(".openidea/settings.toml"), "[notifications]\nsystemNotifications = true\n")
.unwrap();
assert!(!settings.reload().notifications.system_notifications);
}
}
+1 -1
Переглянути файл
@@ -128,7 +128,7 @@ With tabs placed left or right, the tab column is as wide as its longest name, u
| **Scroll to Center** | `⌃L` | `Ctrl+M` |
- **View › Active Editor › Soft-Wrap** wraps long lines in the current editor. To wrap some file types by default, use **Settings › Editor › General**, section **Soft Wraps**.
- **View › Reset Font Size in All Editors** undoes font zoom. Changing the font size with `⌘` / `Ctrl` + mouse wheel can be turned on in **Settings › Editor › General**, section **Mouse Control**.
- **View › Reset Font Size** undoes font zoom in the active editor or focused surface (**View › Reset Font Size in All Editors** resets every open editor). Changing the font size with `⌘` / `Ctrl` + mouse wheel (scoped to **Active editor** by default, or **All editors**) can be turned on in **Settings › Editor › General**, section **Mouse Control**.
- **View › Appearance › Enter Distraction Free Mode** hides tool windows, tabs, the status bar and the gutter and centres the text. Run the same command again to leave.
- Line numbers, whitespace, indent guides, caret style and the intention bulb are in **Settings › Editor › General › Appearance**. Breadcrumbs and sticky lines (the enclosing declarations pinned at the top while you scroll) have their own pages under **Settings › Editor › General**.
+3 -1
Переглянути файл
@@ -94,6 +94,7 @@ While the server runs, OpenIDEA writes its port and token to `mcp/server.json` i
| Commands | `run_command`, `wait_for_run`, `send_run_input`, `stop_run` |
| Command state | `get_run_status`, `read_run_output`, `list_runs` |
| Git | `get_repositories`, `git_status`, `git_diff` |
| HTTP Client | `http_list_requests`, `http_run_request` |
Notes on what they do:
@@ -105,6 +106,7 @@ Notes on what they do:
- `rename_refactoring` renames through the language server, so references that a text search would miss are updated too. It can preview without writing.
- `apply_patch` accepts the Codex `apply_patch` format and unified diffs. Paths must stay inside the project.
- `git_diff` compares files on disk, so unsaved editor text is not included.
- `http_list_requests` lists requests in a project `.http` / `.rest` file; `http_run_request` sends one by index (optional `env` from `http-client.env.json`), asks first, and returns status plus a truncated body — not request headers or body.
## Commands in the Run tool window
@@ -122,7 +124,7 @@ Plugins can add more tools; they appear in the same list. A plugin tool marked a
## Safety
- **Untrusted projects** expose only the read-only tools. Tools that write files, rename, reformat, build or run need a project you have trusted.
- **Running and building ask first.** `execute_run_configuration`, `build_project` and `run_command` show a dialog in OpenIDEA naming the client, the project, the tool and what will run. Choose **Allow** or **Deny**; several requests queue up.
- **Running and building ask first.** `execute_run_configuration`, `build_project`, `run_command` and `http_run_request` show a dialog in OpenIDEA naming the client, the project, the tool and what will run. Choose **Allow** or **Deny**; several requests queue up.
- Tools that write refuse paths outside the project.
## Limits
+3 -3
Переглянути файл
@@ -27,8 +27,8 @@ The **Refactor** menu has IntelliJ IDEA's refactorings with their usual shortcut
| **Inline…** | `⌥⌘N` | `Ctrl+Alt+N` | Language server |
| **Move…** | `F6` | `F6` | Language server (symbols); the IDE (files and folders) |
| **Safe Delete…** | `⌘⌦` | `Alt+Delete` | The IDE, using the server's references |
| **Pull Members Up…** | — | — | Java only |
| **Push Members Down…** | — | — | Java only |
| **Pull Members Up…** | — | — | Java; PHP with Phoxite |
| **Push Members Down…** | — | — | Java; PHP with Phoxite |
## Rename
@@ -80,7 +80,7 @@ In the editor, **Move…** on a symbol runs the server's move refactoring, where
## Pull Members Up and Push Members Down
These move fields and methods between a Java class and its superclasses or subclasses. A dialog lets you pick the members and the destination; problems the move would cause are listed in **Problems Detected** before you continue. They are provided by the Java extension bundled with OpenIDEA, so they are not available for other languages.
These move fields and methods between a class and its superclasses or subclasses, in Java and, with Phoxite as the PHP server, in PHP (methods, properties and constants). A dialog lets you pick the members and the destination; problems the move would cause are listed in **Problems Detected** before you continue. For Java they are provided by the extension bundled with OpenIDEA, for PHP by Phoxite; they are not available for other languages or other PHP servers.
## Undo
+1 -1
Переглянути файл
@@ -64,7 +64,7 @@ To create a theme or icon theme, see [Themes](/en/plugins/guides/themes) and [Ic
- **Enable ligatures** for fonts with programming ligatures.
- **Typography Settings**: **Main font weight**, **Bold font weight**, and a **Fallback font** for characters the main font lacks.
To change the size temporarily, use **Increase Font Size** (`⌥⇧.` / `Alt+Shift+.`) and **Decrease Font Size** (`⌥⇧,` / `Alt+Shift+,`); **View › Reset Font Size in All Editors** goes back. On macOS, **Change font size with Command+Mouse Wheel** in **Settings › Editor › General** enables wheel zoom.
To change the size temporarily in the active editor, use **Increase Font Size** (`⌥⇧.` / `Alt+Shift+.`) and **Decrease Font Size** (`⌥⇧,` / `Alt+Shift+,`); **View › Reset Font Size** (or **View › Reset Font Size in All Editors**) goes back. In **Settings › Editor › General**, **Change font size with Ctrl/Command+Mouse Wheel** enables wheel zoom for the **Active editor** (default) or **All editors**.
### UI font and zoom
+25 -24
Переглянути файл
@@ -100,30 +100,31 @@ The user approves **required** capabilities as a whole when installing. **Option
Each contribution point is a table (`[contributes.settings]`) or an array of tables (`[[contributes.commands]]`). Contributions are live as soon as the plugin is enabled, before its code loads.
| Point | Declaration | Code needed | Guide |
| ------------------- | -------------------------------------------------------------------------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `commands` | `id`, `title`, `category?`, `when?`, `icon?` | to run them | [Commands and actions](/en/plugins/guides/commands) |
| `menus` | `menu`, `command`, `when?`, `view?`, `submenu?` | no | [Commands and actions](/en/plugins/guides/commands) |
| `keymaps` | `command`, `key`, `mac?` | no | [Commands and actions](/en/plugins/guides/commands) |
| `statusBar` | `id`, `text`, `tooltip?`, `command?`, `align?`, `priority?` | no | [Views and decorations](/en/plugins/guides/views) |
| `settings` | `schema` (a JSON file), or `pages` (API 1.3), `title?` | no | [Lifecycle and events](/en/plugins/lifecycle#settings) |
| `secrets` | `name`, `label`, `description?` | to use them | [Permissions and capabilities](/en/plugins/capabilities#secrets) |
| `providers` | `kinds`, `languages` | yes | [Language features](/en/plugins/guides/language-features) |
| `documentIndexers` | `extensions` | yes | [Indexing](/en/plugins/guides/indexing) |
| `endpoints` | `files` (API 1.3) | yes | [README: Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
| `views` | `id`, `title`, `icon?`, `location`, `web?`, `group?`, `when?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
| `customEditors` | `id`, `title`, `patterns`, `priority`, `layout?`, `web?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
| `markerIcons` | `id`, `icon`, `iconDark?`, `markers?`, `tooltip?` (API 1.3): gutter marker icons | no | [Language features](/en/plugins/guides/language-features) |
| `fileIcons` | `id`, `patterns`, `icon`, `iconDark?` | no | [Icon themes](/en/plugins/guides/icon-themes) |
| `fileTemplates` | `id`, `name`, `extension`, `path`; API 1.3: `fileName`, `variables` | no | [File actions](/en/plugins/guides/file-actions) |
| `snippets` | `language`, `path` (API 1.4) | no | [Language features](/en/plugins/guides/language-features) |
| `commitChecks` | `id`, `title` | yes | [README: Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
| `runDetectors` | `id`, `name`, `files`, `command`, `args?`, `test?`, `framework?` | no | [Run targets](/en/plugins/guides/run-targets) |
| `runConfigurations` | `files` (API 1.4) | yes | [Run targets](/en/plugins/guides/run-targets) |
| `mcpTools` | `name`, `description`, `inputSchema`, `readOnly`, `destructive` (API 1.4) | yes | [MCP tools](/en/plugins/guides/mcp) |
| `themes` | `path`, `editor-scheme?` | no | [Themes](/en/plugins/guides/themes) |
| `iconThemes` | `id`, `label`, `path` | no | [Icon themes](/en/plugins/guides/icon-themes) |
| `languages` | `path` (a `languages/<id>.toml` file) | no | [Adding a language](/en/languages/adding) |
| Point | Declaration | Code needed | Guide |
| ------------------- | -------------------------------------------------------------------------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `commands` | `id`, `title`, `category?`, `when?`, `icon?` | to run them | [Commands and actions](/en/plugins/guides/commands) |
| `menus` | `menu`, `command`, `when?`, `view?`, `submenu?` | no | [Commands and actions](/en/plugins/guides/commands) |
| `keymaps` | `command`, `key`, `mac?` | no | [Commands and actions](/en/plugins/guides/commands) |
| `statusBar` | `id`, `text`, `tooltip?`, `command?`, `align?`, `priority?` | no | [Views and decorations](/en/plugins/guides/views) |
| `settings` | `schema` (a JSON file), or `pages` (API 1.3), `title?` | no | [Lifecycle and events](/en/plugins/lifecycle#settings) |
| `secrets` | `name`, `label`, `description?` | to use them | [Permissions and capabilities](/en/plugins/capabilities#secrets) |
| `providers` | `kinds`, `languages` | yes | [Language features](/en/plugins/guides/language-features) |
| `documentIndexers` | `extensions` | yes | [Indexing](/en/plugins/guides/indexing) |
| `endpoints` | `files` (API 1.3) | yes | [README: Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
| `views` | `id`, `title`, `icon?`, `location`, `web?`, `group?`, `when?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
| `customEditors` | `id`, `title`, `patterns`, `priority`, `layout?`, `web?` | without `web` | [Views and decorations](/en/plugins/guides/views) |
| `markerIcons` | `id`, `icon`, `iconDark?`, `markers?`, `tooltip?` (API 1.3): gutter marker icons | no | [Language features](/en/plugins/guides/language-features) |
| `fileIcons` | `id`, `patterns`, `icon`, `iconDark?` | no | [Icon themes](/en/plugins/guides/icon-themes) |
| `fileTemplates` | `id`, `name`, `extension`, `path`; API 1.3: `fileName`, `variables` | no | [File actions](/en/plugins/guides/file-actions) |
| `snippets` | `language`, `path` (API 1.4) | no | [Language features](/en/plugins/guides/language-features) |
| `commitChecks` | `id`, `title` | yes | [README: Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
| `serverCommands` | `server`, `command`, `run` (API 1.9) | yes | [README: Commands a server hands to the client](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commands-a-server-hands-to-the-client) |
| `runDetectors` | `id`, `name`, `files`, `command`, `args?`, `test?`, `framework?` | no | [Run targets](/en/plugins/guides/run-targets) |
| `runConfigurations` | `files` (API 1.4) | yes | [Run targets](/en/plugins/guides/run-targets) |
| `mcpTools` | `name`, `description`, `inputSchema`, `readOnly`, `destructive` (API 1.4) | yes | [MCP tools](/en/plugins/guides/mcp) |
| `themes` | `path`, `editor-scheme?` | no | [Themes](/en/plugins/guides/themes) |
| `iconThemes` | `id`, `label`, `path` | no | [Icon themes](/en/plugins/guides/icon-themes) |
| `languages` | `path` (a `languages/<id>.toml` file) | no | [Adding a language](/en/languages/adding) |
Item ids (commands, views, themes, …) match `[a-z0-9][a-z0-9._-]*`, at most 64 characters. Menus, shortcuts and status bar items refer to the plugin's own declared commands; inside the IDE a command's action id is `plugin.<plugin id>.<command id>`.
+7 -6
Переглянути файл
@@ -152,12 +152,13 @@ Sub-tables such as `[editor.general]`, `[editor.appearance]`, `[editor.completio
### `[notifications]`
| Key | Default | Description |
| --------------------------- | ----------- | ------------------------------------------------------------ |
| `balloons` | `true` | **Display balloon notifications**. |
| `sound` | `false` | **Play sound**. |
| `groups.<group-id>.display` | `"balloon"` | Popup type per group: `balloon`, `sticky` or `none`. |
| `groups.<group-id>.log` | `true` | Also list the notification in the Notifications tool window. |
| Key | Default | Description |
| --------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `balloons` | `true` | **Display balloon notifications**. |
| `sound` | `false` | **Play sound**. |
| `systemNotifications` | `true` | **Enable system notifications**. When a balloon is shown and no OpenIDEA window is focused, the same title and text also go to the OS notification centre. On by default; client/local only. Click focuses the window that raised the toast; balloon actions stay in the IDE. **Windows:** a click is reported only while the toast is on screen, not after it moves to Action Center. Desktop `permission_state` always reports Granted without an OS prompt — that is not proof Do Not Disturb or system notification settings allow delivery. |
| `groups.<group-id>.display` | `"balloon"` | Popup type per group: `balloon`, `sticky` or `none`. |
| `groups.<group-id>.log` | `true` | Also list the notification in the Notifications tool window. |
### `[terminal]`
+1 -1
Переглянути файл
@@ -128,7 +128,7 @@ description: "多光标与选区、行编辑、剪贴板历史、代码折叠、
| **滚动到中央** | `⌃L` | `Ctrl+M` |
- **视图 › 活动编辑器 › 软换行** 让当前编辑器的长行自动折行。想让某些文件类型默认软换行,在 **设置 › 编辑器 › 常规** 的 **软换行** 一节中设置。
- **视图 › 重置所有编辑器中的字体大小** 撤销字体缩放。用 `⌘` / `Ctrl` + 鼠标滚轮调整字号的功能默认关闭,可在 **设置 › 编辑器 › 常规** 的 **鼠标控制** 一节中打开。
- **视图 › 重置字体大小** 撤销当前编辑器或焦点区域的字体缩放(**视图 › 重置所有编辑器中的字体大小** 会重置所有打开的编辑器)。用 `⌘` / `Ctrl` + 鼠标滚轮调整字号的功能默认关闭,可在 **设置 › 编辑器 › 常规** 的 **鼠标控制** 一节中打开,并可选择作用于 **当前编辑器**(默认)或 **所有编辑器**。
- **视图 › 外观 › 进入无干扰模式** 隐藏工具窗口、标签页、状态栏和装订区域,并让正文居中。再执行一次即可退出。
- 行号、空白字符、缩进参考线、光标样式和意图灯泡在 **设置 › 编辑器 › 常规 › 外观** 中设置。痕迹导航和粘滞行(滚动时把所在的声明固定在顶部)在 **设置 › 编辑器 › 常规** 下各有单独的页面。
+14 -12
Переглянути файл
@@ -82,17 +82,18 @@ stdio 配置大致如下(路径以你机器上的为准):
## 工具
| 类别 | 工具 |
| ---------- | --------------------------------------------------------------------------- |
| 文件 | `read_file`、`list_directory_tree`、`create_new_file`、`apply_patch` |
| 搜索 | `search_text`、`search_regex`、`search_symbol`、`search_file` |
| 编辑器 | `get_all_open_file_paths`、`get_current_file`、`open_file_in_editor` |
| 代码 | `get_symbol_info`、`find_references`、`rename_refactoring`、`reformat_file` |
| 问题 | `get_file_problems`、`get_project_problems`、`check_files` |
| 运行与构建 | `get_run_configurations`、`execute_run_configuration`、`build_project` |
| 命令 | `run_command`、`wait_for_run`、`send_run_input`、`stop_run` |
| 命令状态 | `get_run_status`、`read_run_output`、`list_runs` |
| Git | `get_repositories`、`git_status`、`git_diff` |
| 类别 | 工具 |
| ----------- | --------------------------------------------------------------------------- |
| 文件 | `read_file`、`list_directory_tree`、`create_new_file`、`apply_patch` |
| 搜索 | `search_text`、`search_regex`、`search_symbol`、`search_file` |
| 编辑器 | `get_all_open_file_paths`、`get_current_file`、`open_file_in_editor` |
| 代码 | `get_symbol_info`、`find_references`、`rename_refactoring`、`reformat_file` |
| 问题 | `get_file_problems`、`get_project_problems`、`check_files` |
| 运行与构建 | `get_run_configurations`、`execute_run_configuration`、`build_project` |
| 命令 | `run_command`、`wait_for_run`、`send_run_input`、`stop_run` |
| 命令状态 | `get_run_status`、`read_run_output`、`list_runs` |
| Git | `get_repositories`、`git_status`、`git_diff` |
| HTTP 客户端 | `http_list_requests`、`http_run_request` |
几点说明:
@@ -104,6 +105,7 @@ stdio 配置大致如下(路径以你机器上的为准):
- `rename_refactoring` 通过语言服务器重命名,文本搜索找不到的引用也会一并更新;也可以只预览不写入。
- `apply_patch` 接受 Codex 的 `apply_patch` 格式和 unified diff,路径必须在项目内。
- `git_diff` 比较的是磁盘上的文件,不包含编辑器中尚未保存的内容。
- `http_list_requests` 列出项目中 `.http` / `.rest` 文件里的请求;`http_run_request` 按索引发送其中一个(可选 `env`,来自 `http-client.env.json`),会先询问,并返回状态和截断后的响应体——不含请求头或请求体。
## 在运行工具窗口中执行命令
@@ -121,7 +123,7 @@ stdio 配置大致如下(路径以你机器上的为准):
## 安全
- **未受信任的项目** 只开放只读工具。写文件、重命名、重新格式化、构建或运行的工具都要求项目已被信任。
- **运行和构建会先询问。** `execute_run_configuration`、`build_project` 和 `run_command` 会在 OpenIDEA 中弹出对话框,说明是哪个客户端、哪个项目、哪个工具以及要运行什么,选择 **允许** 或 **拒绝**;多个请求会排队。
- **运行和构建会先询问。** `execute_run_configuration`、`build_project`、`run_command` 和 `http_run_request` 会在 OpenIDEA 中弹出对话框,说明是哪个客户端、哪个项目、哪个工具以及要运行什么,选择 **允许** 或 **拒绝**;多个请求会排队。
- 会写入的工具拒绝项目之外的路径。
## 限制
+3 -3
Переглянути файл
@@ -27,8 +27,8 @@ description: "重命名、引入与提取、内联、移动、更改签名和安
| **内联…** | `⌥⌘N` | `Ctrl+Alt+N` | 语言服务器 |
| **移动…** | `F6` | `F6` | 语言服务器(符号);IDE(文件和文件夹) |
| **安全删除…** | `⌘⌦` | `Alt+Delete` | IDE,借助服务器查找引用 |
| **上拉成员…** | — | — | 仅 Java |
| **下推成员…** | — | — | 仅 Java |
| **上拉成员…** | — | — | Java;PHP(使用 Phoxite) |
| **下推成员…** | — | — | Java;PHP(使用 Phoxite) |
## 重命名
@@ -73,7 +73,7 @@ description: "重命名、引入与提取、内联、移动、更改签名和安
## 上拉成员与下推成员
用于在 Java 类和它的父类或子类之间移动字段和方法。在对话框中选择成员和目标类;移动会引起的问题会先在 **检测到问题** 中列出,再决定是否继续。这两项由 OpenIDEA 自带的 Java 扩展提供,其他语言不可用。
用于在类和它的父类或子类之间移动字段和方法:支持 Java,以及使用 Phoxite 作为 PHP 服务器时的 PHP(方法、属性和常量)。在对话框中选择成员和目标类;移动会引起的问题会先在 **检测到问题** 中列出,再决定是否继续。Java 由 OpenIDEA 自带的扩展提供,PHP 由 Phoxite 提供;其他语言和其他 PHP 服务器不可用。
## 撤销
+1 -1
Переглянути файл
@@ -64,7 +64,7 @@ OpenIDEA 会把主题(以及其中附带的编辑器配色方案)转换为
- **启用连字**:用于带编程连字的字体。
- **排版设置**:**主字重**、**粗体字重**,以及主字体缺少字符时使用的 **备用字体**。
临时调整字号可以用 **增大字体**(`⌥⇧.` / `Alt+Shift+.`)和 **减小字体**(`⌥⇧,` / `Alt+Shift+,`),用 **视图 › 重置所有编辑器中的字体大小** 恢复。在 macOS 上,开启 **设置 › 编辑器 › 常规** 中的 **使用 Command+鼠标滚轮更改字体大小** 后可以用滚轮缩放。
在当前编辑器中临时调整字号可以用 **增大字体**(`⌥⇧.` / `Alt+Shift+.`)和 **减小字体**(`⌥⇧,` / `Alt+Shift+,`),用 **视图 › 重置字体大小**(或 **视图 › 重置所有编辑器中的字体大小**)恢复。在 **设置 › 编辑器 › 常规** 中开启 **使用 Ctrl/Command+鼠标滚轮更改字体大小** 后可以用滚轮缩放,并可选择作用于 **当前编辑器**(默认)或 **所有编辑器**。
### 界面字体与缩放
+25 -24
Переглянути файл
@@ -100,30 +100,31 @@ optional = ["net:api.openai.com", "secrets"]
每个贡献点是一张表(`[contributes.settings]`)或一个表数组(`[[contributes.commands]]`)。插件启用后贡献立即生效,不需要等代码加载。
| 贡献点 | 声明字段 | 需要代码 | 指南 |
| ------------------- | ---------------------------------------------------------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `commands` | `id`、`title`、`category?`、`when?`、`icon?` | 执行时需要 | [命令与动作](/zh/plugins/guides/commands) |
| `menus` | `menu`、`command`、`when?`、`view?`、`submenu?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
| `keymaps` | `command`、`key`、`mac?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
| `statusBar` | `id`、`text`、`tooltip?`、`command?`、`align?`、`priority?` | 否 | [视图与装饰](/zh/plugins/guides/views) |
| `settings` | `schema`(JSON 文件)或 `pages`(API 1.3)、`title?` | 否 | [生命周期与事件](/zh/plugins/lifecycle) |
| `secrets` | `name`、`label`、`description?` | 使用时需要 | [权限与能力](/zh/plugins/capabilities) |
| `providers` | `kinds`、`languages` | 是 | [语言功能](/zh/plugins/guides/language-features) |
| `documentIndexers` | `extensions` | 是 | [索引](/zh/plugins/guides/indexing) |
| `endpoints` | `files`(API 1.3) | 是 | [README:Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
| `views` | `id`、`title`、`icon?`、`location`、`web?`、`group?`、`when?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
| `customEditors` | `id`、`title`、`patterns`、`priority`、`layout?`、`web?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
| `markerIcons` | `id`、`icon`、`iconDark?`、`markers?`、`tooltip?`(API 1.3):装订区标记图标 | 否 | [语言功能](/zh/plugins/guides/language-features) |
| `fileIcons` | `id`、`patterns`、`icon`、`iconDark?` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
| `fileTemplates` | `id`、`name`、`extension`、`path`;API 1.3:`fileName`、`variables` | 否 | [文件操作](/zh/plugins/guides/file-actions) |
| `snippets` | `language`、`path`(API 1.4) | 否 | [语言功能](/zh/plugins/guides/language-features) |
| `commitChecks` | `id`、`title` | 是 | [README:Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
| `runDetectors` | `id`、`name`、`files`、`command`、`args?`、`test?`、`framework?` | 否 | [运行目标](/zh/plugins/guides/run-targets) |
| `runConfigurations` | `files`(API 1.4) | 是 | [运行目标](/zh/plugins/guides/run-targets) |
| `mcpTools` | `name`、`description`、`inputSchema`、`readOnly`、`destructive`(API 1.4) | 是 | [MCP 工具](/zh/plugins/guides/mcp) |
| `themes` | `path`、`editor-scheme?` | 否 | [主题](/zh/plugins/guides/themes) |
| `iconThemes` | `id`、`label`、`path` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
| `languages` | `path`(`languages/<id>.toml` 格式的文件) | 否 | [添加语言](/zh/languages/adding) |
| 贡献点 | 声明字段 | 需要代码 | 指南 |
| ------------------- | ---------------------------------------------------------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `commands` | `id`、`title`、`category?`、`when?`、`icon?` | 执行时需要 | [命令与动作](/zh/plugins/guides/commands) |
| `menus` | `menu`、`command`、`when?`、`view?`、`submenu?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
| `keymaps` | `command`、`key`、`mac?` | 否 | [命令与动作](/zh/plugins/guides/commands) |
| `statusBar` | `id`、`text`、`tooltip?`、`command?`、`align?`、`priority?` | 否 | [视图与装饰](/zh/plugins/guides/views) |
| `settings` | `schema`(JSON 文件)或 `pages`(API 1.3)、`title?` | 否 | [生命周期与事件](/zh/plugins/lifecycle) |
| `secrets` | `name`、`label`、`description?` | 使用时需要 | [权限与能力](/zh/plugins/capabilities) |
| `providers` | `kinds`、`languages` | 是 | [语言功能](/zh/plugins/guides/language-features) |
| `documentIndexers` | `extensions` | 是 | [索引](/zh/plugins/guides/indexing) |
| `endpoints` | `files`(API 1.3) | 是 | [README:Project HTTP endpoints](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#project-http-endpoints-api-13) |
| `views` | `id`、`title`、`icon?`、`location`、`web?`、`group?`、`when?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
| `customEditors` | `id`、`title`、`patterns`、`priority`、`layout?`、`web?` | 无 `web` 时需要 | [视图与装饰](/zh/plugins/guides/views) |
| `markerIcons` | `id`、`icon`、`iconDark?`、`markers?`、`tooltip?`(API 1.3):装订区标记图标 | 否 | [语言功能](/zh/plugins/guides/language-features) |
| `fileIcons` | `id`、`patterns`、`icon`、`iconDark?` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
| `fileTemplates` | `id`、`name`、`extension`、`path`;API 1.3:`fileName`、`variables` | 否 | [文件操作](/zh/plugins/guides/file-actions) |
| `snippets` | `language`、`path`(API 1.4) | 否 | [语言功能](/zh/plugins/guides/language-features) |
| `commitChecks` | `id`、`title` | 是 | [README:Commits](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commits) |
| `serverCommands` | `server`、`command`、`run`(API 1.9) | 是 | [README:Commands a server hands to the client](https://github.com/l0ng-ai/openidea/blob/main/plugins/README.md#commands-a-server-hands-to-the-client) |
| `runDetectors` | `id`、`name`、`files`、`command`、`args?`、`test?`、`framework?` | 否 | [运行目标](/zh/plugins/guides/run-targets) |
| `runConfigurations` | `files`(API 1.4) | 是 | [运行目标](/zh/plugins/guides/run-targets) |
| `mcpTools` | `name`、`description`、`inputSchema`、`readOnly`、`destructive`(API 1.4) | 是 | [MCP 工具](/zh/plugins/guides/mcp) |
| `themes` | `path`、`editor-scheme?` | 否 | [主题](/zh/plugins/guides/themes) |
| `iconThemes` | `id`、`label`、`path` | 否 | [图标主题](/zh/plugins/guides/icon-themes) |
| `languages` | `path`(`languages/<id>.toml` 格式的文件) | 否 | [添加语言](/zh/languages/adding) |
条目 id(命令、视图、主题等)匹配 `[a-z0-9][a-z0-9._-]*`,不超过 64 个字符。菜单、快捷键和状态栏项只能引用插件自己声明的命令;在 IDE 内部,命令的操作 id 是 `plugin.<plugin id>.<command id>`。
+7 -6
Переглянути файл
@@ -152,12 +152,13 @@ exclude = ["**/.git", "**/node_modules", "**/target", "**/dist"]
### `[notifications]`
| 键 | 默认值 | 说明 |
| --------------------------- | ----------- | --------------------------------------------------- |
| `balloons` | `true` | **显示气球通知**。 |
| `sound` | `false` | **播放声音**。 |
| `groups.<group-id>.display` | `"balloon"` | 每个分组的弹出方式:`balloon`、`sticky` 或 `none`。 |
| `groups.<group-id>.log` | `true` | 同时在通知工具窗口中列出。 |
| 键 | 默认值 | 说明 |
| --------------------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `balloons` | `true` | **显示气球通知**。 |
| `sound` | `false` | **播放声音**。 |
| `systemNotifications` | `true` | **启用系统通知**。气球通知显示且没有任何 OpenIDEA 窗口处于焦点时,相同的标题和正文也会发到操作系统通知中心。默认开启;仅客户端/本机设置。点击会聚焦发出该通知的窗口;气球操作仍只在 IDE 内。**Windows:**仅在 toast 仍显示在屏幕上时可收到点击,进入操作中心后不再触发。桌面端 `permission_state` 始终返回 Granted 且不会弹出系统授权——这并不表示勿扰模式或系统通知设置允许显示。 |
| `groups.<group-id>.display` | `"balloon"` | 每个分组的弹出方式:`balloon`、`sticky` 或 `none`。 |
| `groups.<group-id>.log` | `true` | 同时在通知工具窗口中列出。 |
### `[terminal]`
+2 -1
Переглянути файл
@@ -255,7 +255,8 @@ async function selectDraft(page: Page) {
}
async function chooseModel(page: Page, name: string) {
await modelButton(page).click();
await page.getByRole("option", { name, exact: true }).click();
// A model row also holds its Configure button, whose label joins the option's name.
await page.getByRole("option", { name: new RegExp(`^${name}\\b`) }).click();
await page.keyboard.press("Escape");
await box(page).focus();
}
+58
Переглянути файл
@@ -761,3 +761,61 @@ test("Find in Conversation skips user-select:none summaries and closed <details>
}));
expect(expandedHighlights).toEqual({ thoughtOpen: true, findCount: 2, currentCount: 1 });
});
test("keeps ordered, bulleted and task list markers unclipped inside measured rows when zoomed in", async ({
page,
}) => {
const numbered = Array.from({ length: 10 }, (_, i) => `${i + 1}. **Item ${i + 1}**\n - Nested bullet`).join("\n");
await openReply(page, `## Feature Gaps\n\n${numbered}\n\n- [x] Checked task\n- [ ] Open task`);
await page.evaluate(async (task) => {
const storePath = "/src/features/agents/store.ts";
const actionsPath = "/src/platform/actions.ts";
const store = await import(storePath);
const { executeAction } = await import(actionsPath);
store.openTaskInEditorLocation(task.id);
await new Promise((r) => setTimeout(r, 150));
const stream = document.querySelector<HTMLElement>("[class*='_stream_']");
stream?.focus();
for (let i = 0; i < 12; i++) await executeAction("editor.increaseFontSize");
}, TASK);
const stream = page.locator("[class*='_stream_']:visible");
const row = stream.locator("[class*='_conversationRow_'][data-measured]", { has: page.locator("ol") });
await expect(row).toBeVisible();
const bounds = await row.evaluate((rowEl) => {
const rowLeft = rowEl.getBoundingClientRect().left;
const items = [...rowEl.querySelectorAll<HTMLElement>("ol > li, ul > li")];
const markers = items
.filter((li) => getComputedStyle(li, "::before").content !== "none")
.map((li) => {
const rect = li.getBoundingClientRect();
const before = getComputedStyle(li, "::before");
const lineHeight = Number.parseFloat(getComputedStyle(li).lineHeight);
const markerRight = rect.right - Number.parseFloat(before.right);
const markerLeft = markerRight - Number.parseFloat(before.width);
return {
text: li.firstChild?.textContent?.trim() ?? "",
offsetFromRowLeft: Math.round((markerLeft - rowLeft) * 100) / 100,
singleLine: Number.parseFloat(before.height) <= lineHeight * 1.15,
};
});
const checkboxes = [...rowEl.querySelectorAll<HTMLInputElement>('li > input[type="checkbox"]')].map((input) => ({
offsetFromRowLeft: Math.round((input.getBoundingClientRect().left - rowLeft) * 100) / 100,
}));
return { fontSize: getComputedStyle(streamElement()!).fontSize, markers, checkboxes };
function streamElement() {
return rowEl.closest<HTMLElement>("[class*='_stream_']");
}
});
expect(bounds.fontSize).toBe("25px");
expect(bounds.markers.length).toBeGreaterThanOrEqual(10);
for (const m of bounds.markers) {
expect(m.singleLine, `single-line marker for ${m.text}`).toBe(true);
expect(m.offsetFromRowLeft, `marker for ${m.text}`).toBeGreaterThanOrEqual(0);
}
for (const cb of bounds.checkboxes) {
expect(cb.offsetFromRowLeft).toBeGreaterThanOrEqual(0);
}
});
+3
Переглянути файл
@@ -0,0 +1,3 @@
# Per-user IDE state
/shelf/
/changelists.json
+31
Переглянути файл
@@ -157,6 +157,7 @@ work), but 0.1 code no longer runs: rebuild it against the 1.0 SDK.
| `fileIcons` | `id`, `patterns` (file names), `icon` (SVG), `iconDark?` — whatever icon theme is in use | no |
| `fileTemplates` | `id`, `name`, `extension`, `path`; API 1.3: `fileName`, `variables = [{ name, prompt }]` — New menu | no |
| `commitChecks` | `id`, `title` — a before-commit check in Commit Options (see _Commits_) | yes |
| `serverCommands` | `server`, `command`, `run` — a language server's client command run by this plugin's command (API 1.9; see _Commands a server hands to the client_) |
A `viewItem.context` menu needs `view`, the id of one of the plugin's own
views. It adds the commands to the right-click menu of the items in that
@@ -432,6 +433,8 @@ matching SDK. Released 1.8 plugins keep working. New in 1.9:
(Debug runs the configuration and attaches to a process the run starts). See
_Environment and debugger_ under _Runs, terminal sessions and test results_.
- **`[[contributes.serverCommands]]`** routes a command a language server leaves
to the client (a code lens's, a code action's) to the plugin's own command.
- **Requests to a language server.** `Project::language_server_request` and
`language_server_notify` send a running server its own methods, behind the
high-risk `lsp:<server>` capability. See _Requests to a language server_.
@@ -781,6 +784,34 @@ project.language_server_notify("phoxite", "phoxite/refresh", None)?;
is at most 256 bytes, params at most 1 MiB.
- The project must be trusted; otherwise the call is `denied`.
#### Commands a server hands to the client
A server's code lens, code action or inlay hint can carry a command the server
does not execute itself (it is not in its `executeCommandProvider`): the client
is meant to. A plugin claims such a command in its manifest, and the IDE runs
the plugin's own command instead of failing with "no language server provides
command":
```toml
[[contributes.commands]]
id = "model-view"
title = "Show the Eloquent Model"
[[contributes.serverCommands]]
server = "phoxite" # the server whose results carry the command
command = "laravel.modelView" # the command name in the server's result
run = "model-view" # this plugin's command
```
- `run` gets the command's `arguments` array as JSON in `arg`, in the window and
editor where the lens or action was activated.
- The manifest must declare `lsp:<server>`, and the claim counts only while the
plugin holds that grant.
- A command listed in the server's `executeCommandProvider` still goes to the
server.
- When two installed plugins claim the same `server` and `command`, the first
one loaded keeps it and the conflict is logged.
In tests, `MockHost::set_language_server_response(server, method, json)` makes
a server run and answer, and `language_server_requests()` /
`language_server_notifications()` list what the plugin sent.
+1
Переглянути файл
@@ -16,6 +16,7 @@ dunce.workspace = true
[dependencies]
tauri = { version = "2", features = [] }
tauri-plugin-opener = "2"
tauri-plugin-notification = "2.8.1"
tauri-plugin-dialog = { version = "2", default-features = false, features = ["xdg-portal"] }
tauri-plugin-mcp-bridge = "0.13"
tauri-plugin-window-state = "2"
+1
Переглянути файл
@@ -16,6 +16,7 @@
"core:webview:allow-set-webview-background-color",
"opener:default",
"opener:allow-reveal-item-in-dir",
"notification:default",
"dialog:default",
"core:window:allow-destroy",
"core:window:allow-close",
+9
Переглянути файл
@@ -348,6 +348,15 @@ pub async fn debug_free_port(window: Window, state: State<'_, AppState>) -> IdeR
ide_host::ops::debug::debug_free_port(&state.host, window.label()).await
}
#[tauri::command]
#[specta::specta]
pub async fn debug_unity_processes(
window: tauri::Window,
state: State<'_, AppState>,
) -> IdeResult<Vec<attach::AttachableProcess>> {
ide_host::ops::debug::debug_unity_processes(&state.host, window.label()).await
}
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
#[tauri::command]
+4
Переглянути файл
@@ -35,6 +35,7 @@ pub mod lsp;
pub mod mcp;
pub mod nav;
pub mod notebook;
pub mod notification;
pub mod perf;
pub mod plugin;
pub mod profiler;
@@ -199,6 +200,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
clipboard::clipboard_has_image,
clipboard::clipboard_image,
clipboard::clipboard_set_file_list,
notification::show_system_notification,
fonts::system_font_families,
doc::doc_open,
doc::doc_open_virtual,
@@ -250,6 +252,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
nav::find_files_named,
nav::find_dirs,
nav::find_symbols,
nav::find_symbols_named,
nav::mark_recent,
nav::recent_files,
nav::remove_recent,
@@ -550,6 +553,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
debug::debug_data_breakpoint_info,
debug::debug_attachable_processes,
debug::debug_free_port,
debug::debug_unity_processes,
debug::debug_listen_for_jvm,
debug::debug_redefine_classes,
debug::debug_jvm_memory_classes,
+28 -6
Переглянути файл
@@ -24,8 +24,13 @@ pub fn index_file_extensions(window: Window, state: State<'_, AppState>) -> IdeR
#[tauri::command]
#[specta::specta]
pub fn find_files(window: Window, state: State<'_, AppState>, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
ide_host::ops::nav::find_files(&state.host, window.label(), query, limit)
pub async fn find_files(
window: Window,
state: State<'_, AppState>,
query: String,
limit: u32,
) -> IdeResult<Vec<FileMatch>> {
ide_host::ops::nav::find_files(&state.host, window.label(), query, limit).await
}
#[tauri::command]
@@ -37,8 +42,13 @@ pub async fn find_files_named(window: Window, state: State<'_, AppState>, name:
/// Folders holding indexed files, for `@` references.
#[tauri::command]
#[specta::specta]
pub fn find_dirs(window: Window, state: State<'_, AppState>, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
ide_host::ops::nav::find_dirs(&state.host, window.label(), query, limit)
pub async fn find_dirs(
window: Window,
state: State<'_, AppState>,
query: String,
limit: u32,
) -> IdeResult<Vec<FileMatch>> {
ide_host::ops::nav::find_dirs(&state.host, window.label(), query, limit).await
}
/// Spring Web mapping sources for the request-path index of Search Everywhere.
@@ -53,14 +63,26 @@ pub fn spring_route_sources(
#[tauri::command]
#[specta::specta]
pub fn find_symbols(
pub async fn find_symbols(
window: Window,
state: State<'_, AppState>,
query: String,
filter: SymbolFilter,
limit: u32,
) -> IdeResult<Vec<SymbolMatch>> {
ide_host::ops::nav::find_symbols(&state.host, window.label(), query, filter, limit)
ide_host::ops::nav::find_symbols(&state.host, window.label(), query, filter, limit).await
}
/// Index symbols named exactly one of `names` inside `within` (an agent task's folder).
#[tauri::command]
#[specta::specta]
pub async fn find_symbols_named(
window: Window,
state: State<'_, AppState>,
names: Vec<String>,
within: IpcPath,
) -> IdeResult<Vec<SymbolMatch>> {
ide_host::ops::nav::find_symbols_named(&state.host, window.label(), names, within).await
}
#[tauri::command]
+12
Переглянути файл
@@ -0,0 +1,12 @@
//! IPC for OS notification centre toasts.
use ide_core::IdeResult;
use tauri::{AppHandle, Window};
/// When a balloon is shown and OpenIDEA is unfocused, mirror it to the OS.
#[tauri::command]
#[specta::specta]
pub fn show_system_notification(app: AppHandle, window: Window, title: String, body: String) -> IdeResult<()> {
crate::system_notifications::show(&app, window.label(), title, body);
Ok(())
}
+44 -9
Переглянути файл
@@ -6,6 +6,7 @@ use crate::windows::{self, Launch, OpenOutcome, WindowsState};
use ide_core::{IdeError, IdeResult, RequestId};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::collections::BTreeMap;
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use tauri::ipc::Channel;
@@ -636,12 +637,18 @@ pub async fn app_install_update(
}
/// Release notes of `version` from the update manifest (`latest.json`), read
/// through the configured source. An install records the notes it saw, so this
/// is only for an update installed outside the app. `Ok(None)` when the manifest
/// covers another version or carries no notes.
/// through the configured source: the `notes` text under `"en"` plus any
/// `notes.<lang>` translations keyed by their base language code, so the page
/// can show the UI's language and fall back to English. An install records the
/// notes it saw, so this is only for an update installed outside the app.
/// `Ok(None)` when the manifest covers another version or carries no notes.
#[tauri::command]
#[specta::specta]
pub async fn app_release_notes(app: AppHandle, version: String, source: UpdateSource) -> IdeResult<Option<String>> {
pub async fn app_release_notes(
app: AppHandle,
version: String,
source: UpdateSource,
) -> IdeResult<Option<BTreeMap<String, String>>> {
let endpoints = match update_endpoint_env() {
Some(url) => vec![url],
None => source_endpoints(config_endpoints(&app), source, is_nightly(&app.package_info().version.to_string())),
@@ -667,14 +674,32 @@ pub async fn app_release_notes(app: AppHandle, version: String, source: UpdateSo
Ok(None)
}
/// The notes of `version` in a manifest, when that is the entry it lists.
fn notes_for(manifest: &str, version: &str) -> Option<String> {
/// The notes of `version` in a manifest, when that is the entry it lists: the
/// `notes` text as English and each `notes.<lang>` entry under its base language
/// code (`notes.zh-CN` → `zh`), the way the UI's locales are keyed.
fn notes_for(manifest: &str, version: &str) -> Option<BTreeMap<String, String>> {
let value: serde_json::Value = serde_json::from_str(manifest).ok()?;
if value.get("version")?.as_str()? != version {
return None;
}
let notes = value.get("notes")?.as_str()?.trim();
(!notes.is_empty()).then(|| notes.to_string())
let mut notes = BTreeMap::new();
let entry =
|text: &serde_json::Value| text.as_str().map(str::trim).filter(|text| !text.is_empty()).map(str::to_string);
if let Some(text) = value.get("notes").and_then(entry) {
notes.insert("en".to_owned(), text);
}
for (key, text) in value.as_object().into_iter().flatten() {
let Some(tag) = key.strip_prefix("notes.").and_then(|tag| tag.split(['-', '_']).next()) else {
continue;
};
if tag.is_empty() {
continue;
}
if let Some(text) = entry(text) {
notes.insert(tag.to_ascii_lowercase(), text);
}
}
(!notes.is_empty()).then_some(notes)
}
#[cfg(test)]
@@ -684,10 +709,20 @@ mod tests {
let manifest = serde_json::json!({
"version": "0.1.40",
"notes": "## What's new\n\n- dev containers",
"notes.zh": "## 新变化\n\n- 开发容器",
"notes.ko-KR": "## 새 소식",
"notes.pl": " ",
"pub_date": "2026-11-01T00:00:00Z",
})
.to_string();
assert_eq!(notes_for(&manifest, "0.1.40").as_deref(), Some("## What's new\n\n- dev containers"));
assert_eq!(
notes_for(&manifest, "0.1.40"),
Some(BTreeMap::from([
("en".to_owned(), "## What's new\n\n- dev containers".to_owned()),
("zh".to_owned(), "## 新变化\n\n- 开发容器".to_owned()),
("ko".to_owned(), "## 새 소식".to_owned()),
]))
);
// Another version, empty notes, or not JSON: nothing to show.
assert_eq!(notes_for(&manifest, "0.1.41"), None);
assert_eq!(notes_for(r#"{ "version": "0.1.40", "notes": " " }"#, "0.1.40"), None);
+6 -1
Переглянути файл
@@ -26,6 +26,7 @@ mod relaunch;
mod remote_container;
mod remote_dev;
mod remote_wsl;
mod system_notifications;
mod state;
mod theme_frame;
@@ -121,7 +122,10 @@ pub fn run() {
// Install before window-state restores maximized geometry during window creation.
#[cfg(windows)]
let app = app.plugin(window_work_area::init());
let app = app.plugin(tauri_plugin_opener::init()).plugin(tauri_plugin_dialog::init());
let app = app
.plugin(tauri_plugin_opener::init())
.plugin(tauri_plugin_notification::init())
.plugin(tauri_plugin_dialog::init());
#[cfg(target_os = "linux")]
let app = app.plugin(linux_window_state::plugin());
#[cfg(not(target_os = "linux"))]
@@ -220,6 +224,7 @@ pub fn run() {
windows::report_cli_error(app.handle(), error);
}
app.manage(application_focus::ApplicationFocus::default());
system_notifications::init(app.handle());
#[cfg(target_os = "macos")]
macos::intercept_system_quit(app.handle());
#[cfg(target_os = "macos")]
+2 -1
Переглянути файл
@@ -439,7 +439,8 @@ pub fn spec(os: Os) -> Vec<Entry> {
SEP,
act("view.quickSwitchScheme", "Quick Switch Scheme…"),
SEP,
act("editor.resetFontSize", "Reset Font Size in All Editors"),
act("editor.resetFontSize", "Reset Font Size"),
act("editor.resetFontSizeAll", "Reset Font Size in All Editors"),
SEP,
act("view.notifications", "Notifications"),
],
+1
Переглянути файл
@@ -179,6 +179,7 @@ impl AppState {
/// Called on the event-loop thread (window destruction, the `close_project`
/// command), so it must not wait for the project's workers to shut down.
pub fn close_project(&self, window: &str) {
crate::system_notifications::clear_window(window);
self.remote_dev.disconnect(window);
self.host.close_project_detached(window);
}
+150
Переглянути файл
@@ -0,0 +1,150 @@
//! OS notification centre toasts for in-IDE balloons while OpenIDEA is unfocused.
//!
//! Driven by `show_system_notification` from the notification store. Honour
//! global `[notifications].systemNotifications`; suppressed while any window is
//! active. Click focuses the window that raised the toast — balloon actions stay
//! in the IDE.
use parking_lot::Mutex;
use std::collections::HashMap;
use std::sync::LazyLock;
use std::sync::atomic::{AtomicBool, AtomicI32, Ordering};
use tauri::{AppHandle, Manager};
use tauri_plugin_notification::{NotificationExt, PermissionState};
const MAX_TARGETS: usize = 64;
struct State {
ready: AtomicBool,
next_id: AtomicI32,
/// Native notification id → owning window label.
targets: Mutex<HashMap<i32, String>>,
}
impl State {
fn new() -> Self {
Self { ready: AtomicBool::new(false), next_id: AtomicI32::new(1), targets: Mutex::new(HashMap::new()) }
}
fn put_target(&self, id: i32, window: String) {
let mut targets = self.targets.lock();
targets.insert(id, window);
while targets.len() > MAX_TARGETS {
let oldest = targets.keys().copied().min();
if let Some(oldest) = oldest {
targets.remove(&oldest);
} else {
break;
}
}
}
fn take_target(&self, id: i32) -> Option<String> {
self.targets.lock().remove(&id)
}
fn clear_window(&self, window: &str) {
self.targets.lock().retain(|_, w| w != window);
}
}
static STATE: LazyLock<State> = LazyLock::new(State::new);
/// Registers the notification plugin's activation handler once.
pub fn init(app: &AppHandle) {
if STATE.ready.swap(true, Ordering::AcqRel) {
return;
}
let handle = app.clone();
if let Err(e) = app.notification().on_action(move |performed| {
if performed.action_id() != "tap" {
return;
}
let Some(n) = performed.notification() else { return };
activate(&handle, n.id());
}) {
tracing::warn!("system notifications: cannot register action handler: {e}");
STATE.ready.store(false, Ordering::Release);
}
}
/// Project closed or window replaced: drop click targets for that owner.
pub fn clear_window(window: &str) {
STATE.clear_window(window);
}
/// Show an OS toast when the setting is on and no OpenIDEA window is focused.
pub fn show(app: &AppHandle, window: &str, title: String, body: String) {
let owner = crate::state::AppState::owner_window(window).to_owned();
let app = app.clone();
let _ = app.clone().run_on_main_thread(move || deliver(&app, &owner, &title, &body));
}
fn deliver(app: &AppHandle, window: &str, title: &str, body: &str) {
let Some(state) = app.try_state::<crate::state::AppState>() else { return };
let settings = state.host.global_settings.effective();
if !settings.notifications.system_notifications {
return;
}
if crate::application_focus::application_active(app) {
return;
}
init(app);
if !STATE.ready.load(Ordering::Acquire) {
return;
}
// Desktop always reports Granted without an OS prompt (not proof of visible delivery).
let granted = app
.notification()
.permission_state()
.ok()
.or_else(|| app.notification().request_permission().ok())
.is_some_and(|s| s == PermissionState::Granted);
if !granted {
return;
}
let id = STATE.next_id.fetch_add(1, Ordering::Relaxed);
STATE.put_target(id, window.to_owned());
let mut builder = app.notification().builder().id(id).title(title).body(body);
if settings.notifications.sound {
builder = builder.sound("default");
}
if let Err(e) = builder.show() {
tracing::debug!("system notification not shown: {e}");
STATE.take_target(id);
}
}
fn activate(app: &AppHandle, id: i32) {
let Some(window_label) = STATE.take_target(id) else { return };
let app = app.clone();
let _ = app.clone().run_on_main_thread(move || {
let Some(window) = app.get_webview_window(&window_label) else { return };
let _ = window.unminimize();
let _ = window.show();
let _ = window.set_focus();
});
}
#[cfg(test)]
mod tests {
use super::*;
use ide_core::settings::NotificationSettings;
#[test]
fn settings_default_on() {
assert!(NotificationSettings::default().system_notifications);
}
#[test]
fn clear_window_drops_targets() {
let state = State::new();
state.put_target(1, "w1".into());
state.put_target(2, "w2".into());
state.clear_window("w1");
assert!(state.take_target(1).is_none());
assert_eq!(state.take_target(2).as_deref(), Some("w2"));
}
}
+4 -2
Переглянути файл
@@ -1,10 +1,12 @@
//! Tauri runs a command declared without `async` on the main thread, so disk I/O or a
//! large diff there freezes the window (input, painting, every other IPC call).
/// Commands that read or write project files, Local History or `.env` files, or diff two
/// arbitrary texts: they must be `async` and do that work on the blocking pool.
/// Commands that read or write project files, Local History or `.env` files, diff two
/// arbitrary texts, or scan the project index in parallel: they must be `async` and do
/// that work on the blocking pool.
const OFF_MAIN_THREAD: &[(&str, &[&str])] = &[
("doc.rs", &["history_list", "history_content"]),
("nav.rs", &["find_files", "find_dirs", "find_symbols"]),
(
"vcs.rs",
&[
+6 -3
Переглянути файл
@@ -165,6 +165,7 @@ debug_step_in_target trusted project_host bin
debug_step_in_targets trusted project_host bindings async
debug_stop always project_host bindings async
debug_threads trusted project_host bindings async
debug_unity_processes trusted project_host bindings async
debug_variables trusted project_host bindings async
dependency_versions trusted project_host bindings async
deploy_compare trusted project_host bindings async
@@ -216,10 +217,11 @@ docker_snapshot trusted desktop bin
end_process trusted desktop bindings async
env_reload always project_host bindings async
file_dialog_needs_gtk trusted desktop bindings async
find_dirs always project_host bindings sync
find_files always project_host bindings sync
find_dirs always project_host bindings async
find_files always project_host bindings async
find_files_named always project_host bindings async
find_symbols always project_host bindings sync
find_symbols always project_host bindings async
find_symbols_named always project_host bindings async
fs_compare_directories always project_host bindings async
fs_copy always project_host bindings async
fs_copy_merge always project_host bindings async
@@ -534,6 +536,7 @@ settings_list_jetbrains_ides always desktop bin
settings_read_jetbrains always desktop bindings async
settings_removed_theme always project_host bindings sync
settings_set always project_host bindings sync
show_system_notification trusted desktop bindings sync
spell_check always project_host bindings async
spell_suggest always project_host bindings async
spring_route_sources trusted desktop bindings sync
+93 -7
Переглянути файл
@@ -331,6 +331,8 @@ export const commands = {
* false when the clipboard stayed busy; the caller keeps working either way.
*/
clipboardSetFileList: (paths: string[]) => typedError<boolean, IdeError>(__TAURI_INVOKE("clipboard_set_file_list", { paths })),
/** When a balloon is shown and OpenIDEA is unfocused, mirror it to the OS. */
showSystemNotification: (title: string, body: string) => typedError<null, IdeError>(__TAURI_INVOKE("show_system_notification", { title, body })),
/**
* Every installed family, sorted, each flagged monospaced or not. Read on
* first use (off the command threads), cached, and re-queried on `refresh`.
@@ -491,6 +493,8 @@ export const commands = {
/** Folders holding indexed files, for `@` references. */
findDirs: (query: string, limit: number) => typedError<FileMatch[], IdeError>(__TAURI_INVOKE("find_dirs", { query, limit })),
findSymbols: (query: string, filter: SymbolFilter, limit: number) => typedError<SymbolMatch[], IdeError>(__TAURI_INVOKE("find_symbols", { query, filter, limit })),
/** Index symbols named exactly one of `names` inside `within` (an agent task's folder). */
findSymbolsNamed: (names: string[], within: IpcPath) => typedError<SymbolMatch[], IdeError>(__TAURI_INVOKE("find_symbols_named", { names, within })),
markRecent: (path: string) => typedError<null, IdeError>(__TAURI_INVOKE("mark_recent", { path })),
/** Recently opened files, most recent first (⌘E). */
recentFiles: () => typedError<IpcPath[], IdeError>(__TAURI_INVOKE("recent_files")),
@@ -1293,11 +1297,13 @@ export const commands = {
appInstallUpdate: (source: UpdateSource, request: RequestId, onProgress: Channel<UpdateProgress>) => typedError<null, IdeError>(__TAURI_INVOKE("app_install_update", { source, request, onProgress })),
/**
* Release notes of `version` from the update manifest (`latest.json`), read
* through the configured source. An install records the notes it saw, so this
* is only for an update installed outside the app. `Ok(None)` when the manifest
* covers another version or carries no notes.
* through the configured source: the `notes` text under `"en"` plus any
* `notes.<lang>` translations keyed by their base language code, so the page
* can show the UI's language and fall back to English. An install records the
* notes it saw, so this is only for an update installed outside the app.
* `Ok(None)` when the manifest covers another version or carries no notes.
*/
appReleaseNotes: (version: string, source: UpdateSource) => typedError<string | null, IdeError>(__TAURI_INVOKE("app_release_notes", { version, source })),
appReleaseNotes: (version: string, source: UpdateSource) => typedError<{ [key in string]: string } | null, IdeError>(__TAURI_INVOKE("app_release_notes", { version, source })),
debugExceptionFilters: () => typedError<SessionExceptionFilters[], IdeError>(__TAURI_INVOKE("debug_exception_filters")),
debugSetExceptionBreakpoints: (choices: { [key in string]: boolean }) => typedError<null, IdeError>(__TAURI_INVOKE("debug_set_exception_breakpoints", { choices })),
debugSetVariable: (session: DebugSessionId, container: number, name: string, evaluateName: string | null, frameId: number | null, value: string) => typedError<Variable, IdeError>(__TAURI_INVOKE("debug_set_variable", { session, container, name, evaluateName, frameId, value })),
@@ -1331,6 +1337,7 @@ export const commands = {
debugAttachableProcesses: () => typedError<AttachableProcess[], IdeError>(__TAURI_INVOKE("debug_attachable_processes")),
/** A loopback port that is free right now, for a debug agent the launch line starts. */
debugFreePort: () => typedError<number, IdeError>(__TAURI_INVOKE("debug_free_port")),
debugUnityProcesses: () => typedError<AttachableProcess[], IdeError>(__TAURI_INVOKE("debug_unity_processes")),
/**
* Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
* JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
@@ -1888,6 +1895,9 @@ export type AgentAcceptSkipped = {
reason: string,
};
/** Why a task needs the user's attention (native / in-app notify). */
export type AgentAttentionReason = "finished" | "input" | "failed";
/** A task the agent runs in the background while the conversation goes on. */
export type AgentBackgroundTask = {
id: string,
@@ -2094,7 +2104,9 @@ export type AgentEvent =
/** A model lookup started or completed, including unsuccessful lookups. */
{ type: "modelCatalog"; catalog: AgentModelCatalog } |
/** The installed or configured agent providers changed. */
{ type: "providers" };
{ type: "providers" } |
/** The task needs attention once (finished turn, explicit input, or failure). */
{ type: "attention"; task: string; eventId: string; reason: AgentAttentionReason };
/** A form the agent asks the user to fill in (ACP `elicitation/create`, form mode). */
export type AgentForm = {
@@ -2726,7 +2738,7 @@ export type AskpassKind =
/** Yes / no (an unknown host key); answered with `yes` or `no`. */
"confirm";
export type AttachKind = "java" | "node" | "python" | "dotnet" | "go" | "native";
export type AttachKind = "unity" | "java" | "node" | "python" | "dotnet" | "go" | "native";
export type AttachableProcess = {
pid: number,
@@ -2938,7 +2950,9 @@ export type BuildResult = {
messages: BuildMessage[],
};
export type BuildSystem = "maven" | "gradle" | "cargo" | "go" | "typescript" | "cmake" | "dotnet";
export type BuildSystem = "maven" | "gradle" | "cargo" | "go" | "typescript" | "cmake" | "dotnet" |
/** A Java project without a build tool, compiled from its Project Structure. */
"javac";
export type BuildTool = "maven" | "gradle";
@@ -3848,6 +3862,20 @@ export type DataSource_Serialize = {
pluginSourceId?: string | null,
};
/** Database settings: Query Execution and SQL Resolution Scopes. */
export type DatabaseSettings = {
/**
* A console's result sets show under the statements that produced them, in the editor,
* instead of in the Services view's result tabs.
*/
inEditorResults?: boolean,
/**
* Languages & Frameworks › SQL Resolution Scopes: the data source SQL in a file or folder
* resolves against (completion, inspections, navigation), most specific path first.
*/
resolutionScopes?: SqlResolutionScope[],
};
/** System Settings › Date Formats (Git log, Local History, blame). */
export type DateFormatSettings = {
/** Use `pattern` / `use24_hour` instead of the system locale's format. */
@@ -4899,6 +4927,8 @@ export type EditorConfigProps = {
export type EditorGeneralSettings = {
/** Change font size with ⌘ + mouse wheel. */
wheelZoom?: boolean,
/** Scope of ⌘ + mouse wheel font zoom: `active` editor | `all` editors. */
wheelZoomScope?: string,
markdownImageFolder?: string,
markdownImageNamePattern?: string,
/** Drag-and-drop of selected text inside the editor. */
@@ -5253,6 +5283,24 @@ export type FieldValue = { kind: "label"; value: string } | { kind: "readonlyTex
selected: string,
} };
export type FileColor = {
/**
* A built-in scope (`Tests`, `Production`, `Project Files`, `Non-Project Files`) or a
* `scopes` entry, by name.
*/
scope?: string,
/** A palette name (`blue`, `green`, `orange`, `rose`, `violet`, `yellow`, `gray`) or `#rrggbb`. */
color?: string,
};
export type FileColorSettings = {
enabled?: boolean,
editorTabs?: boolean,
projectView?: boolean,
/** Scope → colour; the first scope that holds a file gives its colour. */
colors?: FileColor[],
};
export type FileCoverage = {
path: IpcPath,
/** Sorted by line. */
@@ -5723,6 +5771,11 @@ export type GitSettings = {
pushDialogOnlyProtected?: boolean,
/** Stashes and shelves share one tab. */
combineStashAndShelf?: boolean,
/**
* The non-modal Commit tool window works on the index: Staged / Unstaged groups,
* stage and unstage instead of inclusion checkboxes, and no change lists.
*/
stagingArea?: boolean,
};
export type GoBuildTags = {
@@ -7771,6 +7824,15 @@ export type ModuleStructureSettings = {
dependencies?: ModuleDependency[],
};
/**
* A named set of files: `file:src//*.ts && !file:*.test.ts` (project-relative path patterns
* joined with `||`, `&&`, `!` and parentheses).
*/
export type NamedScope = {
name?: string,
pattern?: string,
};
/**
* Where the Navigation Bar (the file path breadcrumbs) is shown. Mirrors
* IDEA's `View | Appearance | Navigation Bar` (Top / Status Bar / Don't show).
@@ -7917,6 +7979,8 @@ export type NotificationLevel = "info" | "warning" | "error";
export type NotificationSettings = {
balloons?: boolean,
sound?: boolean,
/** Mirror balloon notifications to the OS when no OpenIDEA window is focused. */
systemNotifications?: boolean,
/** Group id → display; groups not listed use their default. */
groups?: { [key in string]: NotificationGroupSettings },
};
@@ -9884,6 +9948,12 @@ export type Settings_Deserialize = {
mcpServer?: McpServerSettings,
/** Tools › Agents: Command Execution Policy. */
agentSecurity?: AgentSecuritySettings,
/** Appearance & Behavior › Scopes: named file sets other settings refer to. */
scopes?: NamedScope[],
/** Appearance & Behavior › File Colors. */
fileColors?: FileColorSettings,
/** Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes. */
database?: DatabaseSettings,
/** Plugin settings (`[contributes.settings]`): plugin id → its values by key. */
plugins?: { [key in string]: { [key in string]: unknown } },
};
@@ -9950,6 +10020,12 @@ export type Settings_Serialize = {
mcpServer: McpServerSettings,
/** Tools › Agents: Command Execution Policy. */
agentSecurity: AgentSecuritySettings,
/** Appearance & Behavior › Scopes: named file sets other settings refer to. */
scopes: NamedScope[],
/** Appearance & Behavior › File Colors. */
fileColors: FileColorSettings,
/** Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes. */
database: DatabaseSettings,
/** Plugin settings (`[contributes.settings]`): plugin id → its values by key. */
plugins: { [key in string]: { [key in string]: unknown } },
};
@@ -10098,6 +10174,16 @@ export type SpellingSettings = {
customDictionaries?: string[],
};
/** One row of SQL Resolution Scopes. */
export type SqlResolutionScope = {
/** Project-relative file or folder, `/`-separated; empty for the whole project. */
path?: string,
/** Data source id. */
dataSource?: string,
/** Schema unqualified names resolve in; empty for the data source's default. */
schema?: string,
};
export type SqlStatement = {
/**
* UTF-16 offsets of the statement text (whitespace trimmed, `;` excluded except
+57 -12
Переглянути файл
@@ -8,7 +8,7 @@ import { acceptCompletion, completionStatus } from "@codemirror/autocomplete";
import { executeAction, registerActions, type Action } from "@/platform/actions";
import { getContext } from "@/platform/context";
import { focusedSoftWrapSurface } from "@/workbench/softWrap";
import { resetSurfaceFontZoom, stepFocusedSurfaceFontZoom } from "@/workbench/contributions";
import { resetSurfaceFontZoom, stepFocusedSurfaceFontZoom, stepSurfaceFontZoomIn } from "@/workbench/contributions";
import { editorController, useGotoLine, useTabs } from "./controller";
import {
addCaretsToLineEnds,
@@ -71,7 +71,7 @@ import { copyReferenceToClipboard, declaredName, qualifiedReference, referenceOf
import { declarationChain } from "./view/outline";
import { recordClipboard } from "./clipboardHistory";
import { useDocMeta, useOutline } from "./model/document";
import { resetAllEditorsFontZoom, stepAllEditorsFontZoom } from "./cm/prefs";
import { resetAllEditorsFontZoom, resetConfiguredEditorsFontZoom, stepConfiguredEditorsFontZoom } from "./cm/prefs";
import { useProject } from "@/platform/project";
import { call, commands } from "@/platform/ipc";
import { editorPrefs } from "@/platform/editorSettings";
@@ -117,7 +117,12 @@ function withView(run: (view: EditorView, slot: EditorSlot) => unknown) {
};
}
/** Routes keyboard font zoom to focus, then the active editor slot. */
function activePaneEditorFocus(): Element | null {
if (typeof document === "undefined") return null;
return document.querySelector(`[data-pane-id="${useTabs.getState().activePane}"] [data-editor-focus]`);
}
/** Routes keyboard font zoom to focus, then the active editor slot or pane surface. */
function stepSurfaceFontSize(delta: 1 | -1): void {
const activeEl = typeof document !== "undefined" ? (document.activeElement as HTMLElement | null) : null;
if (activeEl) {
@@ -126,18 +131,55 @@ function stepSurfaceFontSize(delta: 1 | -1): void {
if (cmEl) {
const cmView = EditorView.findFromDOM(cmEl);
if (cmView) {
stepAllEditorsFontZoom(cmView, delta);
stepConfiguredEditorsFontZoom(cmView, delta);
return;
}
}
}
const slot = activeSlot();
if (!slot?.view) return;
stepAllEditorsFontZoom(slot.view, delta);
if (!slot?.view) {
stepSurfaceFontZoomIn(activePaneEditorFocus(), delta);
return;
}
stepConfiguredEditorsFontZoom(slot.view, delta);
if (!slot.view.hasFocus && !getContext().popupOpen) slot.view.focus();
}
function resetFontSize(): void {
const allScope = editorPrefs().general.wheelZoomScope === "all";
const surfaceOpts = allScope ? { isolatedOnly: true } : undefined;
const activeEl = typeof document !== "undefined" ? (document.activeElement as HTMLElement | null) : null;
if (activeEl) {
if (stepFocusedSurfaceFontZoom(0, surfaceOpts)) return;
if (!allScope) {
const cmEl = activeEl.closest?.(".cm-editor") as HTMLElement | null;
if (cmEl) {
const cmView = EditorView.findFromDOM(cmEl);
if (cmView) {
resetConfiguredEditorsFontZoom(cmView);
return;
}
}
}
}
const slot = activeSlot();
if (!allScope && slot?.view) {
resetConfiguredEditorsFontZoom(slot.view);
return;
}
if (!slot?.view && stepSurfaceFontZoomIn(activePaneEditorFocus(), 0, surfaceOpts)) return;
if (allScope) resetAllFontSize();
}
function resetAllFontSize(): void {
resetAllEditorsFontZoom();
if (typeof document !== "undefined") {
resetSurfaceFontZoom();
}
}
// --- extend / shrink selection ---------------------------------------------------
/** One stack per selection range (by index): ⌥↑ / ⌥↓ work on every caret. */
@@ -934,16 +976,19 @@ export function registerEditorActions(): () => void {
},
{
id: "editor.resetFontSize",
title: "Reset Font Size",
category: "View",
keywords: ["zoom", "font size", "mouse wheel"],
when: "projectOpen",
run: resetFontSize,
},
{
id: "editor.resetFontSizeAll",
title: "Reset Font Size in All Editors",
category: "View",
keywords: ["zoom", "font size", "mouse wheel"],
when: "projectOpen",
run: () => {
resetAllEditorsFontZoom();
if (typeof document !== "undefined") {
resetSurfaceFontZoom();
}
},
run: resetAllFontSize,
},
{
id: "editor.increaseFontSize",
+2 -1
Переглянути файл
@@ -270,7 +270,7 @@ describe("language modes", () => {
}
});
it("colours `this` and `super` as keywords in Java, JavaScript, TypeScript and C++", async () => {
it("colours `this`, `super` and Rust's `self` as keywords", async () => {
const highlighter = tagHighlighter([
{ tag: t.keyword, class: "keyword" },
{ tag: t.self, class: "self" },
@@ -281,6 +281,7 @@ describe("language modes", () => {
["JavaScript", "/p/a.js", "class A extends B { m() { super.m(); this.a = 1; } }", ["super", "this"]],
["TypeScript", "/p/a.ts", "class A extends B { m() { super.m(); this.a = 1; } }", ["super", "this"]],
["C++", "/p/a.cpp", "void A::m() { this->a = 1; }", ["this"]],
["Rust", "/p/a.rs", "impl A { fn m(&self) { self.a = 1; } }", ["self", "self"]],
] as const) {
const support = await loadSupport(findLanguageDescription(mode, path)!);
const found: Array<[string, string]> = [];
+2 -1
Переглянути файл
@@ -308,8 +308,9 @@ const EXTRA_TAGS: Record<string, Parameters<typeof styleTags>[0]> = {
JSX: JS_TAGS,
TSX: JS_TAGS,
Java: JAVA_TAGS,
// CLion colours `this` as a keyword.
// CLion colours `this` as a keyword, RustRover `self`.
"C++": { this: t.keyword },
Rust: { self: t.keyword },
PHP: {
"; ,": t.separator,
"ClassDeclaration/Name BaseClause/Name InterfaceClause/Name": t.className,
+20 -4
Переглянути файл
@@ -37,7 +37,7 @@ import { markdownImages } from "./markdownImages";
import { selectionMarks } from "./selectionMarks";
import { seamlessSelection } from "./selectionLayer";
import { useEditorRegistry } from "@/editor/api";
import type { EditorExtras } from "@/platform/editorSettings";
import { editorPrefs, type EditorExtras } from "@/platform/editorSettings";
import { openideaHighlightStyle } from "./highlight";
import {
cursorHumpLeft,
@@ -426,11 +426,27 @@ export function stepAllEditorsFontZoom(origin: EditorView, delta: number): void
}
}
/** Resets one editor's font zoom to 0. */
export function resetEditorFontZoom(view: EditorView): void {
if (view.state.field(fontZoom, false)) view.dispatch({ effects: setFontZoom.of(0) });
}
/** Resets every open editor's font zoom, and the value new editors start from. */
export function resetAllEditorsFontZoom(): void {
sharedFontZoom = 0;
for (const ed of useEditorRegistry.getState().editors)
if (ed.view.state.field(fontZoom, false)) ed.view.dispatch({ effects: setFontZoom.of(0) });
for (const ed of useEditorRegistry.getState().editors) resetEditorFontZoom(ed.view);
}
/** Steps font zoom according to `editor.general.wheelZoomScope` (`active` editor by default, or `all` editors). */
export function stepConfiguredEditorsFontZoom(origin: EditorView, delta: number): void {
if (editorPrefs().general.wheelZoomScope === "all") stepAllEditorsFontZoom(origin, delta);
else stepFontZoom(origin, delta);
}
/** Resets font zoom according to `editor.general.wheelZoomScope` (`active` editor by default, or `all` editors). */
export function resetConfiguredEditorsFontZoom(origin: EditorView): void {
if (editorPrefs().general.wheelZoomScope === "all") resetAllEditorsFontZoom();
else resetEditorFontZoom(origin);
}
/** Exported for tests: the ⌘/Ctrl+wheel handler of the prefs compartment. */
@@ -438,7 +454,7 @@ export const wheelZoom = EditorView.domEventHandlers({
wheel(e, view) {
if (!e.metaKey && !e.ctrlKey) return false;
e.preventDefault();
stepAllEditorsFontZoom(view, e.deltaY < 0 ? 1 : -1);
stepConfiguredEditorsFontZoom(view, e.deltaY < 0 ? 1 : -1);
return true;
},
});
+12 -4
Переглянути файл
@@ -331,12 +331,20 @@ export class EditorController implements SlotHost {
this.disposers.push(
useTabs.subscribe((s, previous) => {
const open = openKeys(s);
const live = new Set<string>();
for (const pane of Object.values(s.panes)) for (const tab of pane.tabs) live.add(tab.id);
const closed = new Map<string, EditorInput>();
const closedTabs: Tab[] = [];
for (const pane of Object.values(previous.panes))
for (const tab of pane.tabs) if (!open.has(tab.input.key)) closed.set(tab.input.key, tab.input);
if (!this.replacingProject)
for (const input of closed.values())
useContributions.getState().editorKinds.get(input.kind)?.onClose?.(input);
for (const tab of pane.tabs) {
if (!live.has(tab.id)) closedTabs.push(tab);
if (!open.has(tab.input.key)) closed.set(tab.input.key, tab.input);
}
if (!this.replacingProject) {
const kinds = useContributions.getState().editorKinds;
for (const tab of closedTabs) kinds.get(tab.input.kind)?.onTabClose?.(tab.id, tab.input);
for (const input of closed.values()) kinds.get(input.kind)?.onClose?.(input);
}
const prev = prevTabs;
prevTabs = s;
if (
+21 -3
Переглянути файл
@@ -2,11 +2,12 @@ import { afterEach, beforeEach, describe, expect, it } from "vitest";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { useEditorRegistry, type TextEditorHandle } from "@/editor/api";
import { useProject } from "@/platform/project";
import { fontZoom, resetAllEditorsFontZoom, setFontZoom, stepAllEditorsFontZoom, wheelZoom } from "./cm/prefs";
const zoomOf = (view: EditorView) => view.state.field(fontZoom, false);
describe("shared editor font zoom (#2480)", () => {
describe("editor font zoom (active editor by default, all editors when configured)", () => {
const handles: TextEditorHandle[] = [];
const makeView = (extensions = [fontZoom, wheelZoom]) => {
const parent = document.createElement("div");
@@ -17,7 +18,10 @@ describe("shared editor font zoom (#2480)", () => {
handles.push(handle);
return view;
};
beforeEach(() => resetAllEditorsFontZoom());
beforeEach(() => {
resetAllEditorsFontZoom();
useProject.setState({ settings: null });
});
afterEach(() => {
for (const handle of handles) {
useEditorRegistry.getState().editors.delete(handle);
@@ -26,9 +30,23 @@ describe("shared editor font zoom (#2480)", () => {
}
handles.length = 0;
resetAllEditorsFontZoom();
useProject.setState({ settings: null });
});
it("zooms every open editor from ⌘/Ctrl+wheel on one of them", () => {
it("zooms only the active editor from ⌘/Ctrl+wheel by default (IDEA parity)", () => {
const first = makeView();
const second = makeView();
first.contentDOM.dispatchEvent(new WheelEvent("wheel", { bubbles: true, ctrlKey: true, deltaY: -10 }));
expect(zoomOf(first)).toBe(1);
expect(zoomOf(second)).toBe(0);
expect(zoomOf(makeView())).toBe(0);
second.contentDOM.dispatchEvent(new WheelEvent("wheel", { bubbles: true, ctrlKey: true, deltaY: 10 }));
expect(zoomOf(first)).toBe(1);
expect(zoomOf(second)).toBe(-1);
});
it("zooms every open editor from ⌘/Ctrl+wheel when wheelZoomScope is 'all' (#2480)", () => {
useProject.setState({ settings: { editor: { general: { wheelZoomScope: "all" } } } } as never);
const first = makeView();
const second = makeView();
first.contentDOM.dispatchEvent(new WheelEvent("wheel", { bubbles: true, ctrlKey: true, deltaY: -10 }));
+10
Переглянути файл
@@ -13,6 +13,8 @@ import {
import { _provideCodePreview, _provideDocumentAttacher, editorsFor } from "@/editor/api";
import { isUntitledUri } from "@/platform/virtualDocs";
import { formatDocument } from "@/editor/lsp/format";
import { chooserTitle, locationItems, pinToFind } from "@/editor/lsp/navigation";
import { openPopup } from "@/editor/lsp/popupStore";
import { editorController } from "./controller";
import { attachDocument } from "./model/attachment";
import { previewExtensions } from "./cm/preview";
@@ -64,6 +66,14 @@ export function activate(): void | (() => void) {
forgetSavedTabs: () => ctrl.forgetSavedTabs(),
keepSavedTabs: () => ctrl.keepSavedTabs(),
documentHistory: (command) => ctrl.documentHistory(command),
chooseDeclaration: async (targets, name, anchor) =>
openPopup({
kind: "list",
anchor,
title: chooserTitle("declaration", name, targets.length),
items: await locationItems(targets),
pin: pinToFind(name, targets),
}),
reformat: async (path) => {
const handle = editorsFor(path)[0];
return !!handle && (await formatDocument(handle.view, { explicit: false, selectionOnly: false })).applied;
+8 -1
Переглянути файл
@@ -12,11 +12,13 @@ afterEach(() => {
describe("custom editor close lifecycle", () => {
it("notifies once when the last split showing an input closes", async () => {
const close = vi.fn();
const tabClose = vi.fn();
const dispose = registerEditorKind({
kind: "close-probe",
title: () => "Probe",
component: () => null,
onClose: close,
onTabClose: tabClose,
});
controller = new EditorController(createMemoryBackend({}));
controller.start();
@@ -26,9 +28,14 @@ describe("custom editor close lifecycle", () => {
controller.split(useTabs.getState().activePane, "row");
const panes = Object.values(useTabs.getState().panes);
expect(panes).toHaveLength(2);
await controller.closeTab(panes[0]!.id, panes[0]!.tabs[0]!.id);
const firstTabId = panes[0]!.tabs[0]!.id;
const secondTabId = panes[1]!.tabs[0]!.id;
await controller.closeTab(panes[0]!.id, firstTabId);
expect(tabClose).toHaveBeenCalledExactlyOnceWith(firstTabId, input);
expect(close).not.toHaveBeenCalled();
await controller.closeInput(input.key);
expect(tabClose).toHaveBeenCalledTimes(2);
expect(tabClose).toHaveBeenLastCalledWith(secondTabId, input);
expect(close).toHaveBeenCalledExactlyOnceWith(input);
} finally {
dispose();
+11 -4
Переглянути файл
@@ -21,6 +21,7 @@ import {
prepareMenuGroups,
textEditorWrapperFor,
EditorShownProvider,
EditorTabIdProvider,
useContributions,
useFileDecorations,
useEditorDocumentRevision,
@@ -30,6 +31,7 @@ import {
type EditorKindContribution,
} from "@/workbench/contributions";
import { useDistractionFree } from "@/workbench/distractionFree";
import { useFileColors } from "@/workbench/fileColors";
import { EmptyEditor } from "@/workbench/EditorArea";
import {
EmptyState,
@@ -176,6 +178,7 @@ function PaneView({ paneId }: { paneId: string }) {
const dirty = tabs.map((tab, i) => inputDirty(tab.input, kinds) ?? textDirty[i] ?? false);
const colors = useFileDecorations(useShallow(() => paths.map((p) => (p ? (getFileDecoration(p)?.color ?? "") : ""))));
const tints = useFileDecorations(useShallow(() => paths.map((p) => (p ? (getFileDecoration(p)?.tint ?? "") : ""))));
const fileColors = useFileColors("editorTabs");
const hints = useTitleHints();
const [dropZone, setDropZone] = useState<DropZone | null>(null);
@@ -224,7 +227,8 @@ function PaneView({ paneId }: { paneId: string }) {
// (middle click, Shift+click, Delete) alive when its position is None.
showCloseButton,
color: colors[i] || undefined,
tint: tints[i] || undefined,
tint:
tints[i] || (fileColors && t.input.kind === "file" && t.input.path ? fileColors(t.input.path) : undefined),
tooltip: virtualTooltip(t.input) ?? (showFullPathOnHover ? (t.input.path ?? name) : undefined),
trailing:
kindMark || pin ? (
@@ -243,6 +247,7 @@ function PaneView({ paneId }: { paneId: string }) {
dirty,
colors,
tints,
fileColors,
hints,
showExtension,
markModified,
@@ -479,9 +484,11 @@ function KindEditor({ tab, shown, kept = false }: { tab: Tab; shown: boolean; ke
tabIndex={-1}
aria-hidden={shown ? undefined : true}
>
<EditorShownProvider value={shown}>
<Component input={tab.input} />
</EditorShownProvider>
<EditorTabIdProvider value={tab.id}>
<EditorShownProvider value={shown}>
<Component input={tab.input} />
</EditorShownProvider>
</EditorTabIdProvider>
</div>
);
}
Loaded 100 of 224 files, more files were not shown because too many files have changed in this diff. Show more