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

...
Автор SHA1 Повідомлення Дата
l0ng-ai e87495d7b1 fix(debugger): end a program suspended at a breakpoint at once on Stop
For adapters without a terminate request (Delve, java-debug), Stop sends the
program SIGTERM and waits up to 10 s for it to exit. A program suspended in the
debugger cannot act on SIGTERM, and on macOS does not even die of SIGKILL while
debugserver holds it, so Stop sat in "stopping" for the full 10 s and then for
the adapter's terminated event. When the session is suspended, Stop now kills
the program's tree and sends disconnect with terminateDebuggee, which ends it
through the adapter, and skips the wait for shutdown output.
2026-11-16 11:48:34 +08:00
l0ng-ai 92dd70f08b fix(tools): install debugpy when the project's Python has no pip (#3654)
debugpy's private copy was made with python -m pip of the selected interpreter; a uv-made virtualenv has no pip, so the install failed with "No module named pip". The copy is a universal wheel: when the interpreter has no pip, pip runs through uv tool run pip, or another Python on PATH that has it.

Fixes #3619
2026-11-16 11:25:25 +08:00
l0ng-ai 484bbfc704 fix(ui): paint tree row tints as full-width bands (#3652)
File colours, excluded folders and data source colours were painted as the row's own background: inset from the tree's edges, rounded per row, or dropped under hover and selection, so a run of tinted rows read as a ragged stack. The tint is now a full-width band under the row; hover and selection stay rounded on top. Excluded folders and data source colours share the rowTint path.

Fixes #3616
2026-11-16 11:16:55 +08:00
Deng Liuтаdengliu 0b097808f1 fix(agents): increase process-run step indentation and align running tool icons (#3636)
Expanded process runs and turn folds read nearly flat: the guide line sat left of the summary chevron, nested chevrons indented by only a few pixels, and tool rows without output yet had no chevron slot, so their icon jumped right once output arrived. The guide now drops from the parent chevron's centre, tool calls after a thought indent under it, expanded output indents with its row, and output-less tool rows reserve the chevron's width.

Co-authored-by: dengliu <[email protected]>
2026-11-16 11:10:18 +08:00
LU XIANGRUIтаwildcatDownstairs 6cc4b3779c fix(settings): import the JetBrains line height from the font's own height (#3640)
The imported line height was font size × LINE_SPACING and was only written when the export had LINE_SPACING, so tall fonts came out cramped and the default spacing (left out of the export) never applied. It is now the font's measured height (ascent + descent, rounded up per side) × LINE_SPACING (1.2 when absent), written whenever the export sets a font, size or spacing; size × 1.2 is the fallback when the font cannot be measured.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 11:08:13 +08:00
Muuтаmuutot 7d9efa1997 fix(plugins): deliver the post-install settings event to a freshly installed plugin (#3642)
The UI posts a synthetic settings-changed right after an install so event-driven plugins get a first delivery, but changed_settings() took its first snapshot on that call and reported an empty diff, so the event was dropped and the plugin stayed inactive until something else happened in the window. With no snapshot yet for a (window, plugin), it now hands over the current keys; later calls still report only the diff.

Co-authored-by: muutot <[email protected]>
2026-11-16 11:07:37 +08:00
GuoYuтаguoyucode af2e45883d fix(lsp): give a project attached inside the root its own language server (#3643)
Since attached projects inside the root were left out of the content roots (the index already walks them), the language-server manager routed their files to the outer project's server, whose workspace does not contain them (rust-analyzer: "file is not included in any crate"). The manager now gets the content roots plus the projects attached inside the root; index roots are unchanged.

Co-authored-by: guoyucode <[email protected]>
2026-11-16 11:04:29 +08:00
acaoтаamphetamlne 17e11b7904 fix(lsp): bound and cancel Go module deprecation queries (#3333)
The go.mod deprecation query (go list -m -u) could wait indefinitely on a proxy or toolchain download, and superseded checks kept running. Bound it to 60 s and 8 MiB of stdout; a new check of the same document, closing it, revoking execution permission or shutting down cancels it. A supervisor task kills and reaps the process tree even if the caller is dropped; failed or cancelled checks publish nothing.

Co-authored-by: amphetamlne <[email protected]>
2026-11-16 11:01:05 +08:00
acaoтаamphetamlne 22aa1edd61 fix(editor): discard obsolete inlay hint responses (#3253)
Inlay hint requests only checked whether the document had changed, so an older response (e.g. for the previous viewport) could replace newer hints, or restore hints after they were disabled. A refresh or destroy now bumps a generation; work that is no longer wanted is skipped after document sync, before applying results and before marking the server unavailable.

Co-authored-by: amphetamlne <[email protected]>
2026-11-16 10:59:48 +08:00
acaoтаamphetamlne 07c862c785 fix(workspace): detect marked environments before directory-name skips (#3241)
Root detection skipped dot-prefixed and conventional directory names (.venv, venv, .conda) before checking the pyvenv.cfg / conda-meta markers, so those environments were never recorded as excluded roots and their packages could reach the index and VFS walk. Check the markers first; the name-based skip still stops traversal.

Co-authored-by: amphetamlne <[email protected]>
2026-11-16 10:58:53 +08:00
l0ng-ai b60dad7076 feat(languages): Gherkin feature files (#3645)
.feature files are recognised as Gherkin: syntax colours for keywords in every Gherkin language, tags, tables, doc strings and outline placeholders; line comments, two-space indentation, a file icon, and folding of each section, step argument and doc string by indentation.

Part of #797
2026-11-16 10:56:23 +08:00
l0ng-ai 148e45745a feat(database): compare the structure of two schemas (#3644)
Compare Structure picks a source and a target schema, reads their tables with columns, indexes and foreign keys, and shows the differences as a tree (only in source, only in target, different), hiding identical items on request. Checked differences become the migration script that makes the target match the source in the target dialect; changes a dialect cannot express are left as comments. The script is copied or opened in a console of the target; nothing is run.

Closes #2694
2026-11-16 10:52:21 +08:00
l0ng-ai 3287061ea1 feat(database): SQL in MyBatis mapper XML (#3641)
The statements of <select>, <insert>, <update>, <delete> and <sql> in a MyBatis mapper are highlighted as SQL in the data source dialect and get completion, unresolved table/column inspections, Go to Declaration and Quick Documentation against the data source of the file SQL resolution scope (or the only data source). The SQL tools read the mapper with everything but the statements blanked out, so offsets stay the file own; parameters, entities, CDATA, selectKey, comments and the dynamic tags where/set/trim/foreach are read the way MyBatis builds the SQL.

Closes #2457
2026-11-16 10:44:48 +08:00
l0ng-ai 223beeb374 chore(debugger): drop an unused re-export of openAttachPopup (#3639)
pnpm knip failed on main: actions.ts re-exported openAttachPopup, which every caller imports from ./attachPopup directly.
2026-11-16 10:39:30 +08:00
l0ng-ai 8b9ad2e9d1 feat(database): SQL resolution scopes (#3638)
Settings › Languages & Frameworks › SQL Resolution Scopes maps project folders and files to a data source and schema (project settings, database.resolutionScopes). SQL files in a mapped folder resolve against its data source for completion, inspections, navigation and the console toolbar, unless another data source is picked in the toolbar; the deepest row wins and the Project row applies elsewhere. Contributed settings pages can start on the project scope (defaultScope).

Part of #2457
2026-11-16 10:38:58 +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
124 змінених файлів з 5472 додано та 299 видалено

No files matched your search

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

Після

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

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

До

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

Створено
+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)。
+32 -1
Переглянути файл
@@ -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();
@@ -1695,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();
@@ -1797,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),
@@ -1869,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.
@@ -2500,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
@@ -2583,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};
+174
Переглянути файл
@@ -3619,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();
}
+11 -1
Переглянути файл
@@ -71,6 +71,8 @@ pub struct Settings {
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>>,
@@ -508,6 +510,7 @@ impl Default for Settings {
agent_security: AgentSecuritySettings::default(),
scopes: Vec::new(),
file_colors: FileColorSettings::default(),
database: DatabaseSettings::default(),
plugins: BTreeMap::new(),
}
}
@@ -647,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() }
}
}
+24
Переглянути файл
@@ -241,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,
+25 -3
Переглянути файл
@@ -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(())
}
@@ -1229,11 +1244,18 @@ impl DebugManager {
// rdbg's terminate exits the Ruby process without terminating its children.
let graceful =
terminate && s.request == "launch" && s.adapter != "rdbg" && s.supports("supportsTerminateRequest");
// A program suspended in the debugger cannot act on SIGTERM, and on macOS not even die of
// SIGKILL while the debugger holds it: it is killed (with what it started) and the adapter
// is told to end it. A killed program has no shutdown output to wait for.
let killed = own_terminate && !graceful && s.suspended.get();
if killed {
crate::session::signal_debuggee(s, true).await;
}
if !s.conn.is_closed() {
if graceful {
let _ = s.conn.request_timeout("terminate", json!({ "restart": false }), SHUTDOWN_TIMEOUT).await;
}
if !graceful && !own_terminate {
if !graceful && (!own_terminate || killed) {
let _ = s
.conn
.request_timeout(
@@ -1244,7 +1266,7 @@ impl DebugManager {
.await;
}
}
if own_terminate && !graceful {
if own_terminate && !graceful && !killed {
// Signal before anything else: waiting on a request the adapter may not answer
// would delay the shutdown the console is supposed to show.
crate::session::signal_debuggee(s, false).await;
@@ -1263,7 +1285,7 @@ impl DebugManager {
// lets Run start again into an occupied port, so wait for the program first — with the
// connection still open, so a second Stop can find the session and kill it.
crate::session::wait_for_debuggee(s, terminate).await;
if terminate && s.request == "launch" {
if terminate && s.request == "launch" && !killed {
// The adapter reports `terminated` only after it has drained the program's console
// (java-debug waits up to 5 s for the pump): closing before that drops the last
// shutdown lines from the console.
+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);
+93 -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": [
@@ -508,6 +527,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
}
}
"disconnect" => {
// Like Delve: the adapter ends the program it launched.
#[cfg(unix)]
if msg["arguments"]["terminateDebuggee"] == true
&& let Some(pid) = script.debuggee_pid
{
// SAFETY: plain syscall on the test's own child process.
unsafe { libc::kill(pid as i32, libc::SIGKILL) };
}
ok!(msg, Value::Null);
let _ = w.lock().await.shutdown().await;
break;
@@ -878,6 +905,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());
@@ -2274,6 +2327,44 @@ async fn stop_waits_for_the_launched_program_to_exit() {
h.wait_event(|e| matches!(e, DebugEvent::Terminated)).await;
}
/// Delve and other adapters without `terminate`: a program stopped at a breakpoint cannot
/// handle the SIGTERM Stop sends, so Stop has the adapter end it instead of waiting out the grace period.
#[cfg(unix)]
#[tokio::test]
async fn stop_kills_a_program_suspended_at_a_breakpoint_at_once() {
let mut child = std::process::Command::new("python3")
.args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(30)"])
.spawn()
.unwrap();
let pid = child.id();
let exited = Arc::new(AtomicBool::new(false));
{
let exited = exited.clone();
std::thread::spawn(move || {
let _ = child.wait();
exited.store(true, Ordering::Release);
});
}
let h = harness(Script { debuggee_pid: Some(pid), supports_terminate: false, ..Default::default() });
let id = h.start(config()).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
let session = h.manager.session(id).unwrap();
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
tokio::time::sleep(Duration::from_millis(200)).await; // let the program install its trap
let started = Instant::now();
h.manager.stop(id).await.unwrap();
let elapsed = started.elapsed();
assert!(elapsed < Duration::from_secs(3), "stop waited {elapsed:?} for a suspended program");
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], true);
let deadline = Instant::now() + Duration::from_secs(2);
while !exited.load(Ordering::Acquire) {
assert!(Instant::now() < deadline, "the suspended program was left running");
tokio::time::sleep(Duration::from_millis(10)).await;
}
}
#[cfg(unix)]
#[tokio::test]
async fn a_second_stop_kills_the_program_instead_of_waiting() {
+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));
}
+40 -16
Переглянути файл
@@ -650,28 +650,52 @@ fn structure_plan(
kind: BuildKind,
cache: &Path,
) -> IdeResult<Option<compile::BuildPlan>> {
let (roots, jdk) = structure_inputs(root, settings, detected);
compile::structure_plan(
root,
&settings.project_structure,
&roots,
jdk.as_ref(),
&settings.languages.java.language_level,
kind,
cache,
)
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 roots and JDK a build of a project without a build tool uses.
/// 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],
) -> (compile::StructureRoots, Option<compile::StructureJdk>) {
use ide_workspace::roots::{ProjectRoots, RootKind};
let roots = ProjectRoots::compute(detected.to_vec(), &settings.project_structure);
) -> (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 = settings.project_structure.module_settings(root, root);
let module = ps.module_settings(root, root);
let level = module
.map(|m| m.language_level.as_str())
.filter(|l| !l.trim().is_empty())
@@ -690,7 +714,7 @@ pub(crate) fn structure_inputs(
test_resources: of(RootKind::TestResources),
excluded: of(RootKind::Excluded),
};
(roots, jdk)
(ps, roots, jdk)
}
fn cmake_plan(root: &Path, kind: BuildKind, configs: &[ide_run::RunConfig], id: &str) -> IdeResult<compile::BuildPlan> {
+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
});
+8 -7
Переглянути файл
@@ -205,8 +205,8 @@ pub async fn run_tomcat_installations(
/// Id prefix of a Project Structure WAR artifact (a project without a build tool).
const PROJECT_ARTIFACT: &str = "project:";
fn project_web_artifacts(settings: &ide_core::settings::Settings) -> Vec<ide_build::web::WebArtifact> {
ide_build::compile::structure_web_artifacts(&settings.project_structure)
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),
@@ -228,20 +228,19 @@ fn build_project_war(
cache: &std::path::Path,
) -> IdeResult<()> {
use ide_build::compile;
let artifact = settings
.project_structure
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 (roots, jdk) = crate::ops::build::structure_inputs(root, settings, detected);
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,
&settings.project_structure,
&ps,
&roots,
jdk.as_ref(),
&settings.languages.java.language_level,
@@ -278,7 +277,9 @@ pub async fn run_tomcat_artifacts(host: &Host, window: &str) -> IdeResult<Vec<id
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() {
artifacts.extend(project_web_artifacts(&settings));
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
})
+8 -3
Переглянути файл
@@ -677,9 +677,14 @@ impl Shared {
}
let previous =
self.setting_snapshots.lock().insert((client.map(str::to_owned), pkg.id().into()), current.clone());
previous
.map(|old| current.into_iter().filter(|(k, v)| old.get(k) != Some(v)).map(|(k, _)| k).collect())
.unwrap_or_default()
match previous {
// First contact since the plugin loaded (fresh install, update,
// re-enable): hand over every current key, so the synthetic
// post-install `settings-changed` wakes the plugin instead of being
// dropped for having no diff yet.
None => current.into_keys().collect(),
Some(old) => current.into_iter().filter(|(k, v)| old.get(k) != Some(v)).map(|(k, _)| k).collect(),
}
}
pub fn status_snapshot(&self, client: &str) -> Vec<super::PluginStatusItem> {
+39 -2
Переглянути файл
@@ -144,7 +144,7 @@ impl Host {
let lsp = LspManager::new(root.clone(), languages.clone(), sink.clone());
crate::plugins::injections::configure_lsp(&lsp);
lsp.set_execution_allowed(trusted.load(Ordering::Acquire));
lsp.set_content_roots(extra_roots.clone());
lsp.set_content_roots(language_server_roots(&root, extra_roots.clone()));
lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
&root,
&settings.effective().languages.java.maven.linked_projects,
@@ -1224,7 +1224,7 @@ impl Project {
return;
}
let (roots, excludes) = (self.content_roots(), self.exclude_globs());
self.lsp.set_content_roots(roots.clone());
self.lsp.set_content_roots(language_server_roots(&self.root, roots.clone()));
self.lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
&self.root,
&self.settings.effective().languages.java.maven.linked_projects,
@@ -1369,6 +1369,22 @@ fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cac
extra_content_roots(settings, root, build_cache)
}
/// The content roots plus the projects attached inside this one. The index covers those
/// already, but each is a project of its own (a git worktree under the project, a nested
/// Cargo workspace), so its files get a language server rooted there, not at this root.
fn language_server_roots(root: &Path, mut roots: Vec<PathBuf>) -> Vec<PathBuf> {
if let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root)
&& !workspace.is_container(root)
{
for path in workspace.projects {
if path != root && path.starts_with(root) && !roots.contains(&path) {
roots.push(path);
}
}
}
roots
}
/// The roots a file may navigate into: its own root (the workspace member containing it, or
/// the project root) plus that root's configured dependencies. A workspace member depends
/// only on the roots picked per member in Project Structure › Dependencies —
@@ -2163,4 +2179,25 @@ mod content_roots_tests {
let roots = content_roots(&settings, &root, &tmp.path().join("build"));
assert_eq!(roots, vec![shared, dep]);
}
#[test]
fn projects_attached_inside_the_root_get_their_own_language_server_root() {
let tmp = tempfile::tempdir().unwrap();
let ws = dunce::canonicalize(tmp.path()).unwrap();
let (root, nested, other) = (ws.join("app"), ws.join("app/.wt/feature"), ws.join("other"));
for dir in [&nested, &other] {
std::fs::create_dir_all(dir).unwrap();
}
let settings = ide_core::settings::Settings::default();
let build = ws.join("build");
assert!(super::language_server_roots(&root, content_roots(&settings, &root, &build)).is_empty());
ide_workspace::workspace::Workspace::attach(&root, "app", vec![root.clone(), nested.clone(), other.clone()])
.unwrap();
// The index walks the nested project as part of the root ...
let roots = content_roots(&settings, &root, &build);
assert_eq!(roots, vec![other.clone()]);
// ... while its files go to a language server of its own.
assert_eq!(super::language_server_roots(&root, roots), vec![other, nested]);
}
}
+26 -2
Переглянути файл
@@ -6271,10 +6271,15 @@ fn api14_settings_and_input_events_use_other_and_capture_the_editor() {
assert!(f.host.wait_events(Duration::from_secs(5)));
let received: serde_json::Value = serde_json::from_str(&f.run("api14", "events", None).unwrap().unwrap()).unwrap();
let events = received.as_array().unwrap();
assert_eq!(events.len(), 3, "{received}");
assert_eq!(events.len(), 4, "{received}");
// The first synthetic post hands over the current keys ("enabled": false);
// the second is a real diff to true. Keys come from the recomputed
// snapshot, never from the event payload ("another-plugin-key").
assert_eq!(events[0]["kind"], "settings-changed");
assert_eq!(events[0]["data"], "[\"enabled\"]");
assert_eq!(events[2]["kind"], "input-mode-changed");
assert_eq!(events[1]["kind"], "settings-changed");
assert_eq!(events[1]["data"], "[\"enabled\"]");
assert_eq!(events[3]["kind"], "input-mode-changed");
assert_eq!(events[2]["editor"][0], path);
assert_eq!(events[2]["editor"][1][0], serde_json::json!([0, 0, 0, 0]));
}
@@ -7016,3 +7021,22 @@ fn the_language_server_grant_needs_api_1_9() {
let err = f.host.install_from_dir(&pkg, &Consent::all()).unwrap_err();
assert!(err.message.contains("new in plugin API 1.9"), "{err:?}");
}
/// The UI's synthetic post-install `SettingsChanged([])` reaches a plugin that
/// subscribes to `on-event:settings-changed`, though it carries no keys.
#[test]
fn a_freshly_installed_plugin_gets_the_post_install_settings_event() {
let f = fixture(Limits::default());
f.install(&sample("api14"));
use ide_plugin::WorkbenchEvent as E;
// What refreshEventKinds() posts right after commandsChanged (install).
f.host.post_events(Some("main"), vec![E::SettingsChanged(Vec::new())]);
f.host.flush_events_at(Instant::now() + Duration::from_secs(2));
assert!(f.host.wait_events(Duration::from_secs(5)));
let received: serde_json::Value = serde_json::from_str(&f.run("api14", "events", None).unwrap().unwrap()).unwrap();
let events = received.as_array().unwrap();
assert!(
events.iter().any(|e| e["kind"] == "settings-changed"),
"freshly installed plugin got no post-install event: {received}"
);
}
+2
Переглянути файл
@@ -33,6 +33,7 @@ const BUILTIN: &[(&str, &str)] = &[
("gdscript", include_str!("../../../languages/gdscript.toml")),
("gdshader", include_str!("../../../languages/gdshader.toml")),
("go", include_str!("../../../languages/go.toml")),
("gherkin", include_str!("../../../languages/gherkin.toml")),
("gomod", include_str!("../../../languages/gomod.toml")),
("gowork", include_str!("../../../languages/gowork.toml")),
("godot-resource", include_str!("../../../languages/godot-resource.toml")),
@@ -1057,6 +1058,7 @@ mod tests {
("CMakeLists.txt", "cmake"),
("api.proto", "proto"),
("schema.graphql", "graphql"),
("checkout.feature", "gherkin"),
("schema.prisma", "prisma"),
("main.tf", "terraform"),
("prod.tfvars", "terraform-vars"),
+370 -18
Переглянути файл
@@ -6,11 +6,15 @@
use crate::LspManager;
use crate::server::Server;
use ide_core::{DocId, Pos, Range};
use ide_core::{CancellationToken, DocId, Pos, Range};
use serde::Deserialize;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::Arc;
use std::sync::atomic::Ordering;
use std::time::Duration;
use tokio::io::AsyncReadExt;
pub(crate) const CHECK_UPGRADES: &str = "gopls.check_upgrades";
/// gopls answers code lenses once it has loaded the module.
@@ -18,6 +22,43 @@ const ATTEMPTS: u32 = 10;
const RETRY: Duration = Duration::from_secs(2);
/// Producer of the deprecation diagnostics (one full set per go.mod).
const DEPRECATIONS: &str = "go-mod-deprecations";
// This optional background check must not wait indefinitely on a proxy or toolchain download.
const QUERY_TIMEOUT: Duration = Duration::from_secs(60);
const OUTPUT_LIMIT: u64 = 8 * 1024 * 1024;
#[derive(Default)]
pub(crate) struct Queries {
generation: u64,
running: HashMap<DocId, (u64, CancellationToken)>,
}
impl Queries {
fn begin(&mut self, doc: DocId) -> (u64, CancellationToken) {
self.cancel(doc);
self.generation += 1;
let cancel = CancellationToken::new();
self.running.insert(doc, (self.generation, cancel.clone()));
(self.generation, cancel)
}
fn finish(&mut self, doc: DocId, generation: u64) {
if self.running.get(&doc).is_some_and(|(current, _)| *current == generation) {
self.running.remove(&doc);
}
}
pub(crate) fn cancel(&mut self, doc: DocId) {
if let Some((_, cancel)) = self.running.remove(&doc) {
cancel.cancel();
}
}
pub(crate) fn cancel_all(&mut self) {
for (_, (_, cancel)) in self.running.drain() {
cancel.cancel();
}
}
}
fn is_go_mod(path: &Path) -> bool {
path.file_name().is_some_and(|n| n == "go.mod")
@@ -66,6 +107,15 @@ impl LspManager {
}
async fn report_deprecated_modules(&self, doc: DocId, server: &Server) {
let (generation, cancel) = self.go_mod_queries.lock().begin(doc);
self.report_deprecated_modules_query(doc, server, &cancel).await;
self.go_mod_queries.lock().finish(doc, generation);
}
async fn report_deprecated_modules_query(&self, doc: DocId, server: &Server, cancel: &CancellationToken) {
if self.shutting_down.load(Ordering::Acquire) || !self.execution_allowed.load(Ordering::Acquire) {
return;
}
let Some((path, text)) = self.docs.lock().get(&doc).map(|d| (d.path.clone(), d.text.as_str().to_owned()))
else {
return;
@@ -78,10 +128,9 @@ impl LspManager {
let search = crate::launch::server_search_path(&config);
let Some(dir) = path.parent().map(Path::to_path_buf) else { return };
let modules: Vec<String> = required.iter().map(|r| r.path.clone()).collect();
let listed = tokio::task::spawn_blocking(move || list_deprecations(&dir, &search, &modules)).await;
let Ok(Some(deprecated)) = listed else { return };
let Some(deprecated) = list_deprecations(&dir, &search, &modules, cancel).await else { return };
// The document changed meanwhile: its own save runs again.
if self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
if cancel.is_cancelled() || self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
return;
}
let items = required
@@ -157,22 +206,100 @@ struct ListedModule {
}
/// `(module, message)` of each deprecated module in `modules`; `None` when `go` failed.
fn list_deprecations(dir: &Path, search: &std::ffi::OsStr, modules: &[String]) -> Option<Vec<(String, String)>> {
let go: PathBuf = ide_core::tool_path::find_command("go", search, dir)?;
let output = ide_core::process::prepare(&mut std::process::Command::new(go))
.args(["list", "-m", "-u", "-e", "-json"])
.args(modules)
.current_dir(dir)
.env("PATH", search)
.stdin(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.output()
.ok()?;
if output.stdout.is_empty() {
tracing::debug!("go list -m -u in {}: {}", dir.display(), output.status);
async fn list_deprecations(
dir: &Path,
search: &std::ffi::OsStr,
modules: &[String],
cancel: &CancellationToken,
) -> Option<Vec<(String, String)>> {
let (dir, search, modules) = (dir.to_path_buf(), search.to_owned(), modules.to_vec());
let command = tokio::task::spawn_blocking(move || {
let go: PathBuf = ide_core::tool_path::find_command("go", &search, &dir)?;
let mut command = Command::new(go);
command.args(["list", "-m", "-u", "-e", "-json"]).args(modules).current_dir(dir).env("PATH", search);
Some(command)
})
.await
.ok()??;
let output = run_query(command, cancel, QUERY_TIMEOUT).await?;
if output.is_empty() {
return None;
}
Some(parse_deprecations(&output.stdout))
tokio::task::spawn_blocking(move || parse_deprecations(&output)).await.ok()
}
async fn run_query(command: Command, cancel: &CancellationToken, timeout: Duration) -> Option<Vec<u8>> {
let cancel = cancel.child_token();
let _cancel_on_drop = cancel.clone().drop_guard();
// The supervisor owns cleanup even if the caller's future is dropped.
tokio::spawn(async move { supervise_query(command, &cancel, timeout).await }).await.ok().flatten()
}
async fn supervise_query(mut command: Command, cancel: &CancellationToken, timeout: Duration) -> Option<Vec<u8>> {
if cancel.is_cancelled() {
return None;
}
ide_core::process::prepare(&mut command);
ide_core::process::own_group(&mut command);
command.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());
let mut command = tokio::process::Command::from(command);
command.kill_on_drop(true);
let mut child = command.spawn().ok()?;
#[cfg(windows)]
let job = child.id().and_then(ide_core::process::Job::for_pid);
let stdout = child.stdout.take()?;
let mut reader = tokio::spawn(async move {
let mut output = Vec::new();
stdout.take(OUTPUT_LIMIT + 1).read_to_end(&mut output).await.ok()?;
if output.len() as u64 > OUTPUT_LIMIT {
tracing::debug!("go module query exceeded stdout budget");
return None;
}
Some(output)
});
let deadline = tokio::time::sleep(timeout);
tokio::pin!(deadline);
// Drain before reaping: if a descendant holds stdout open, the root's id
// still belongs to this child when cancellation kills its process tree.
let output = tokio::select! {
biased;
() = cancel.cancelled() => None,
() = &mut deadline => {
tracing::debug!("go module query timed out");
None
},
result = &mut reader => result.ok().flatten(),
};
if let Some(bytes) = output {
let status = tokio::select! {
biased;
() = cancel.cancelled() => None,
() = &mut deadline => {
tracing::debug!("go module query timed out");
None
},
status = child.wait() => Some(status),
};
if let Some(status) = status {
return status.ok().map(|_| bytes);
}
}
// The root is still unreaped here, so its process/group id cannot be reused.
if let Some(pid) = child.id() {
let _ = tokio::task::spawn_blocking(move || {
#[cfg(windows)]
if let Some(job) = job {
job.terminate();
return;
}
ide_core::process::kill_tree_of(pid);
})
.await;
}
let _ = child.start_kill();
let _ = child.wait().await;
reader.abort();
None
}
fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
@@ -187,6 +314,231 @@ fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
mod tests {
use super::*;
#[test]
fn queries_cancel_only_the_superseded_document() {
let mut queries = Queries::default();
let (first, old) = queries.begin(DocId(1));
let (_, other) = queries.begin(DocId(2));
let (second, new) = queries.begin(DocId(1));
assert!(old.is_cancelled());
assert!(!other.is_cancelled());
assert!(!new.is_cancelled());
queries.finish(DocId(1), first);
assert_eq!(queries.running.len(), 2);
queries.finish(DocId(1), second);
assert_eq!(queries.running.len(), 1);
queries.cancel_all();
assert!(other.is_cancelled());
assert!(queries.running.is_empty());
}
#[test]
fn closing_one_document_does_not_cancel_another() {
let mut queries = Queries::default();
let (_, closed) = queries.begin(DocId(1));
let (_, other) = queries.begin(DocId(2));
queries.cancel(DocId(1));
assert!(closed.is_cancelled());
assert!(!other.is_cancelled());
assert_eq!(queries.running.len(), 1);
}
#[cfg(unix)]
fn shell(script: &str) -> Command {
let mut command = Command::new("sh");
command.args(["-c", script]);
command
}
#[cfg(target_os = "linux")]
async fn assert_stopped(pid: u32) {
tokio::time::timeout(Duration::from_secs(5), async {
while let Ok(stat) = std::fs::read_to_string(format!("/proc/{pid}/stat")) {
if stat.rsplit_once(") ").unwrap().1.split_whitespace().next() == Some("Z") {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
}
#[cfg(unix)]
#[tokio::test]
async fn cancelled_query_never_spawns() {
let dir = tempfile::tempdir().unwrap();
let cancel = CancellationToken::new();
cancel.cancel();
let mut command = shell("touch started");
command.current_dir(dir.path());
assert!(run_query(command, &cancel, Duration::from_secs(5)).await.is_none());
assert!(!dir.path().join("started").exists());
}
#[cfg(unix)]
#[tokio::test]
async fn queries_keep_working_directories_and_environments_separate() {
let a = tempfile::tempdir().unwrap();
let b = tempfile::tempdir().unwrap();
std::fs::write(a.path().join("value"), "directory-a").unwrap();
std::fs::write(b.path().join("value"), "directory-b").unwrap();
let mut ca = shell("printf '%s:' \"$QUERY_VALUE\"; cat value");
ca.current_dir(a.path()).env("QUERY_VALUE", "env-a");
let mut cb = shell("printf '%s:' \"$QUERY_VALUE\"; cat value");
cb.current_dir(b.path()).env("QUERY_VALUE", "env-b");
let cancel = CancellationToken::new();
let (a, b) = tokio::join!(
run_query(ca, &cancel, Duration::from_secs(5)),
run_query(cb, &cancel, Duration::from_secs(5)),
);
assert_eq!(a.unwrap(), b"env-a:directory-a");
assert_eq!(b.unwrap(), b"env-b:directory-b");
}
#[cfg(unix)]
#[tokio::test]
async fn timeout_kills_and_reaps_the_query() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("echo $$ > pid; exec sleep 2");
command.current_dir(dir.path());
let output = run_query(command, &CancellationToken::new(), Duration::from_secs(1)).await;
assert!(output.is_none());
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap().trim().parse().unwrap();
assert!(!ide_core::process::process_alive(pid));
}
#[cfg(unix)]
#[tokio::test]
async fn cancellation_kills_the_running_query_and_its_child() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("sleep 30 & echo $$ $! > pids; wait");
command.current_dir(dir.path());
let cancel = CancellationToken::new();
let token = cancel.clone();
let task = tokio::spawn(async move { run_query(command, &token, Duration::from_secs(10)).await });
let pids = dir.path().join("pids");
tokio::time::timeout(Duration::from_secs(5), async {
while !std::fs::read_to_string(&pids).is_ok_and(|s| s.split_whitespace().count() == 2) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let text = std::fs::read_to_string(pids).unwrap();
let pids: Vec<u32> = text.split_whitespace().map(|p| p.parse().unwrap()).collect();
cancel.cancel();
assert!(task.await.unwrap().is_none());
assert!(!ide_core::process::process_alive(pids[0]));
// An orphaned child may remain a zombie until the host's init reaps it.
#[cfg(target_os = "linux")]
assert_stopped(pids[1]).await;
#[cfg(not(target_os = "linux"))]
tokio::time::timeout(Duration::from_secs(5), async {
while ide_core::process::process_alive(pids[1]) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
}
#[cfg(unix)]
#[tokio::test]
async fn dropping_the_caller_still_reaps_its_query() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("sleep 30 & echo $$ $! > pid; wait");
command.current_dir(dir.path());
let task =
tokio::spawn(async move { run_query(command, &CancellationToken::new(), Duration::from_secs(10)).await });
let file = dir.path().join("pid");
tokio::time::timeout(Duration::from_secs(5), async {
while !std::fs::read_to_string(&file).is_ok_and(|s| s.split_whitespace().count() == 2) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let text = std::fs::read_to_string(file).unwrap();
let pids: Vec<u32> = text.split_whitespace().map(|p| p.parse().unwrap()).collect();
let pid = pids[0];
task.abort();
let _ = task.await;
tokio::time::timeout(Duration::from_secs(5), async {
while ide_core::process::process_alive(pid) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
#[cfg(target_os = "linux")]
assert_stopped(pids[1]).await;
#[cfg(not(target_os = "linux"))]
tokio::time::timeout(Duration::from_secs(5), async {
while ide_core::process::process_alive(pids[1]) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
}
#[cfg(target_os = "linux")]
#[tokio::test]
async fn timeout_cleans_up_a_child_holding_stdout_after_root_exit() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("sleep 30 & echo $! > pid; exit 0");
command.current_dir(dir.path());
assert!(run_query(command, &CancellationToken::new(), Duration::from_secs(1)).await.is_none());
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap();
assert_stopped(pid.trim().parse().unwrap()).await;
}
#[cfg(unix)]
#[tokio::test]
async fn output_at_the_limit_is_not_truncated() {
let output = run_query(shell("head -c 8388608 /dev/zero"), &CancellationToken::new(), Duration::from_secs(5))
.await
.unwrap();
assert_eq!(output.len() as u64, OUTPUT_LIMIT);
}
#[cfg(unix)]
#[tokio::test]
async fn oversized_output_kills_the_query() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("echo $$ > pid; head -c 8388609 /dev/zero; exec sleep 30");
command.current_dir(dir.path());
assert!(run_query(command, &CancellationToken::new(), Duration::from_secs(5)).await.is_none());
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap().trim().parse().unwrap();
assert!(!ide_core::process::process_alive(pid));
}
#[cfg(unix)]
#[tokio::test]
async fn preserves_output_from_a_nonzero_exit() {
assert_eq!(
run_query(shell("printf partial; exit 1"), &CancellationToken::new(), Duration::from_secs(5))
.await
.unwrap(),
b"partial"
);
}
#[cfg(unix)]
#[tokio::test]
async fn failed_spawn_does_not_poison_a_following_query() {
assert!(
run_query(Command::new("/no/such/go-query"), &CancellationToken::new(), Duration::from_secs(5))
.await
.is_none()
);
assert_eq!(
run_query(shell("printf ok"), &CancellationToken::new(), Duration::from_secs(5)).await.unwrap(),
b"ok"
);
}
fn at(line: u32, from: u32, to: u32) -> Range {
Range { start: Pos { line, col: from }, end: Pos { line, col: to } }
}
+5
Переглянути файл
@@ -240,6 +240,7 @@ pub struct LspManager {
shown_messages: Mutex<HashSet<(String, String)>>,
/// go.mod files whose upgrades gopls has been asked to check this session.
go_mod_checked: Mutex<HashSet<PathBuf>>,
go_mod_queries: Mutex<go_mod::Queries>,
/// Virtual (non-`file:`) URIs a server returned, by the server that owns them.
virtual_origins: Mutex<HashMap<String, ide_core::ServerId>>,
/// Contents fetched for virtual URIs.
@@ -516,6 +517,7 @@ impl LspManager {
configuration_cache: Arc::new(Mutex::new(Default::default())),
shown_messages: Mutex::new(HashSet::new()),
go_mod_checked: Mutex::new(HashSet::new()),
go_mod_queries: Mutex::new(go_mod::Queries::default()),
virtual_origins: Mutex::new(HashMap::new()),
virtual_docs: Mutex::new(HashMap::new()),
virtual_stamps: Mutex::new(HashMap::new()),
@@ -1393,6 +1395,7 @@ impl LspManager {
}
fn close_document(&self, doc: DocId) {
self.go_mod_queries.lock().cancel(doc);
let (d, compose_removed) = {
let mut docs = self.docs.lock();
let Some(d) = docs.remove(&doc) else { return };
@@ -3713,6 +3716,7 @@ impl LspManager {
pub fn set_execution_allowed(&self, allowed: bool) {
let previous = self.execution_allowed.swap(allowed, Ordering::AcqRel);
if !allowed {
self.go_mod_queries.lock().cancel_all();
for server in self.servers.lock().iter() {
server.start_token().cancel();
}
@@ -4057,6 +4061,7 @@ impl LspManager {
pub async fn shutdown_all(&self) {
self.shutting_down.store(true, Ordering::Release);
self.go_mod_queries.lock().cancel_all();
let _reconfigure = self.reconfigure_lock.lock().await;
let servers: Vec<Arc<Server>> = self.servers.lock().clone();
join_all(servers.iter().map(|s| self.stop_instance(s, true))).await;
+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"] {
+51 -3
Переглянути файл
@@ -1256,6 +1256,42 @@ impl Tools {
Err(IdeError::new(ErrorKind::Io, format!("pip install {package} failed ({status})")))
}
/// A command running pip, before its arguments. The interpreter's own pip when it has one;
/// a virtualenv made by uv has none, so then pip through `uv tool run`, or another Python
/// on `PATH` that has it.
fn pip_command(&self, python: PathBuf, emit: Emit) -> Command {
let has_pip = |python: &Path| {
let mut c = self.python_command(python);
c.args(["-m", "pip", "--version"]);
run_quiet(c, Duration::from_secs(20)).is_some_and(|(ok, _)| ok)
};
let module = |python: &Path| {
let mut c = self.python_command(python);
c.args(["-m", "pip"]);
c
};
if has_pip(&python) {
return module(&python);
}
let note = format!("{} has no pip", python.display());
if let Some(uv) = self.which("uv") {
emit(InstallEvent::Line { text: format!("{note}; running pip with uv") });
// pip runs in uv's own Python: the same private working directory applies.
let mut c = self.python_command(uv);
c.args(["tool", "run", "pip"]);
return c;
}
let other = ["python3", "python"]
.into_iter()
.filter_map(|name| ide_core::tool_path::find_command(name, &self.system_path, &self.root))
.find(|p| *p != python && has_pip(p));
if let Some(other) = other {
emit(InstallEvent::Line { text: format!("{note}; using {}", other.display()) });
return module(&other);
}
module(&python)
}
/// The universal (`py3-none-any`) wheel, so the copy works with every interpreter
/// version a project selects, not just the one that installed it.
fn install_pip_target(
@@ -1269,8 +1305,8 @@ impl Tools {
let _ = std::fs::remove_dir_all(&dir);
let lib = python_lib_dir(&self.root, spec.name);
std::fs::create_dir_all(&lib)?;
let mut c = self.python_command(self.python().expect("checked"));
c.args(["-m", "pip", "install", "--disable-pip-version-check", "--no-deps", "--upgrade", "--target"])
let mut c = self.pip_command(self.python().expect("checked"), emit);
c.args(["install", "--disable-pip-version-check", "--no-deps", "--upgrade", "--target"])
.arg(&lib)
.args(["--only-binary=:all:", "--platform", "any", "--implementation", "py"])
.arg(package);
@@ -1296,6 +1332,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 +1486,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()));
+68
Переглянути файл
@@ -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] {
@@ -877,9 +895,14 @@ esac
}
}
/// Installs of one tool name share a process-wide slot: tests installing debugpy take turns.
#[cfg(unix)]
static DEBUGPY_INSTALL: parking_lot::Mutex<()> = parking_lot::Mutex::new(());
#[cfg(unix)]
#[test]
fn selected_python_is_used_for_pip_and_uv_even_with_a_versioned_filename() {
let _guard = DEBUGPY_INSTALL.lock();
let env = Env::new();
env.script(&env.sys, "python3", "exit 99");
let sdk = env._tmp.path().join("python-sdk");
@@ -917,6 +940,51 @@ exit 1
assert!(args.contains(&format!("--python {}", sdk.join("python3.14").display())), "{args}");
}
/// A virtualenv made by uv has no pip: debugpy's private copy is made with pip through uv.
#[cfg(unix)]
#[test]
fn debugpy_installs_through_uv_when_the_selected_python_has_no_pip() {
let _guard = DEBUGPY_INSTALL.lock();
let env = Env::new();
let venv = env._tmp.path().join("project/.venv/bin");
env.script(&venv, "python", "echo \"$(basename \"$0\"): No module named pip\" >&2; exit 1");
let log = env._tmp.path().join("uv.log");
env.script(
&env.sys,
"uv",
&format!(
r#"
echo "$@" >> '{log}'
while [ $# -gt 0 ]; do
if [ "$1" = "--target" ]; then
/bin/mkdir -p "$2/debugpy" "$2/debugpy-1.8.0.dist-info"
/usr/bin/touch "$2/debugpy/__init__.py"
exit 0
fi
shift
done
exit 1
"#,
log = log.display()
),
);
let tools = env.tools().with_runtime(BTreeMap::from([("python".into(), venv.join("python"))]), BTreeMap::new());
let lines = Mutex::new(Vec::new());
let info = tools
.install("debugpy", &langs(), &CancellationToken::new(), &|e| {
if let InstallEvent::Line { text } = e {
lines.lock().push(text);
}
})
.unwrap();
assert_eq!(info.status, ToolStatus::Installed);
assert_eq!(info.version.as_deref(), Some("1.8.0"));
let args = fs::read_to_string(log).unwrap();
assert!(args.starts_with("tool run pip install "), "{args}");
assert!(args.contains("--platform any"), "{args}");
assert!(lines.lock().iter().any(|l| l.contains("has no pip")));
}
#[test]
fn a_cancelled_install_leaves_the_previous_one_in_place() {
let tmp = tempfile::tempdir().unwrap();
+110 -3
Переглянути файл
@@ -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",
@@ -139,9 +140,6 @@ pub fn detect(root: &Path) -> Vec<SourceFolder> {
}
let found: Vec<String> = out[before..].iter().map(|r| r.path.clone()).collect();
for name in dirs {
if name.starts_with('.') || SKIP_DIRS.contains(&name.as_str()) {
continue;
}
let child = join(&rel, &name);
// Roots are not searched for nested modules (`src/main/java` can be huge).
if found.iter().any(|f| *f == child || f.is_empty() && name == "src") {
@@ -154,6 +152,11 @@ pub fn detect(root: &Path) -> Vec<SourceFolder> {
}
continue;
}
// Skipping discovery is not an exclusion: marked hidden/conventional
// environments still need an explicit root for index and watcher filtering.
if name.starts_with('.') || SKIP_DIRS.contains(&name.as_str()) {
continue;
}
queue.push_back((child, depth + 1));
}
}
@@ -238,6 +241,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"))
@@ -557,6 +574,96 @@ mod tests {
assert!(affects_roots(Path::new("code10/pyvenv.cfg")));
}
#[test]
fn marked_environments_are_detected_before_name_based_walk_skips() {
let dir = tree(&[
".venv/pyvenv.cfg",
".venv/Lib/site-packages/pkg/setup.py",
".conda/conda-meta/history",
"venv/pyvenv.cfg",
"nested/.custom/pyvenv.cfg",
"nested/.custom/lib/pkg/pyproject.toml",
"build/business.go",
"bin/business.go",
"env/business.go",
"dist/business.go",
".ordinary/setup.py",
]);
assert_eq!(
summary(&detect(dir.path())),
vec![
"[email protected]/conda-meta",
"[email protected]/pyvenv.cfg",
"nested/.custom=Excluded@nested/.custom/pyvenv.cfg",
"venv=Excluded@venv/pyvenv.cfg",
]
);
}
#[test]
fn marked_environment_detection_preserves_source_roots_and_user_overrides() {
let dir = tree(&["Cargo.toml", "src/pyvenv.cfg", ".venv/pyvenv.cfg", ".conda/conda-meta/history"]);
let detected = detect(dir.path());
assert!(detected.iter().any(|r| r.path == ".venv" && r.kind == RootKind::Excluded));
assert!(detected.iter().any(|r| r.path == "src" && r.kind == RootKind::Source));
let settings = ide_core::settings::ProjectStructureSettings {
source_roots: vec![".venv".into()],
unmarked: vec![".conda".into()],
..Default::default()
};
let effective = super::super::ProjectRoots::compute(detected, &settings);
assert!(effective.excluded_globs().is_empty());
assert_eq!(effective.root_for(".venv/app.py").unwrap().kind, RootKind::Source);
}
#[test]
fn environment_markers_require_the_expected_file_type_and_respect_walk_boundaries() {
let dir = tree(&[
"pyvenv.cfg",
"app.py",
".not_venv/pyvenv.cfg/",
".not_conda/conda-meta",
".hidden/nested/pyvenv.cfg",
"a/b/c/d/e/f/g/pyvenv.cfg",
"at/b/c/d/e/f/pyvenv.cfg",
]);
// An environment opened as the project remains browsable. Hidden parents and
// the existing depth budget are not traversed to discover more environments.
assert_eq!(summary(&detect(dir.path())), vec!["at/b/c/d/e/f=Excluded@at/b/c/d/e/f/pyvenv.cfg"]);
}
#[test]
fn detected_environment_roots_prune_vfs_walk_without_hiding_business_directories() {
let dir = tree(&[
".venv/pyvenv.cfg",
".venv/Lib/site-packages/pkg/setup.py",
"internal/build/build.go",
"env/business.go",
"bin/business.go",
"dist/business.go",
"service/go.mod",
]);
for i in 0..128 {
fs::write(dir.path().join(format!(".venv/Lib/site-packages/pkg/dep{i}.py")), "").unwrap();
}
let walk = |excludes: &[String]| {
let files = std::sync::Mutex::new(Vec::new());
ide_vfs::walk_files(dir.path(), excludes, |path| {
files.lock().unwrap().push(path.strip_prefix(dir.path()).unwrap().to_owned());
});
let mut files = files.into_inner().unwrap();
files.sort();
files
};
let before = walk(&[]);
let roots = super::super::ProjectRoots::compute(detect(dir.path()), &Default::default());
let after = walk(&roots.excluded_globs());
assert_eq!(before.len(), 135);
assert_eq!(after.len(), 5);
assert_eq!(after, before.into_iter().filter(|p| !p.starts_with(".venv")).collect::<Vec<_>>());
assert_eq!(roots.root_for("service/go.mod").unwrap().kind, RootKind::Source);
}
#[test]
fn first_ecosystem_wins_for_a_shared_folder() {
// A Gradle build with a frontend: `build` stays Gradle's, `src` is not a Node root.
+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);
}
}
+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]`
+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]`
+83
Переглянути файл
@@ -819,3 +819,86 @@ test("keeps ordered, bulleted and task list markers unclipped inside measured ro
expect(cb.offsetFromRowLeft).toBeGreaterThanOrEqual(0);
}
});
test("indents process-run thoughts and tool calls clearly and aligns output-less tool icons", async ({ page }) => {
await openReply(page, "All checks passed.");
await page.evaluate(async (task) => {
const storePath = "/src/features/agents/store.ts";
const store = await import(storePath);
store.useAgents.setState({
tasks: new Map([[task.id, { ...task, status: "running" as const }]]),
entries: new Map([
[
task.id,
[
{ type: "thought", text: "**Checking CI Status**\n\nInspecting workflow runs." },
{
type: "tool",
id: "t1",
title: "gh pr checks 3631 --repo l0ng-ai/openidea",
kind: "execute",
status: "completed",
locations: [],
output: "All checks pending",
diffs: [],
},
{ type: "thought", text: "**Tracking Continuous Integration**\n\nWaiting for E2E." },
{
type: "tool",
id: "t2",
title: "read_bash",
kind: "other",
status: "completed",
locations: [],
output: "E2E pass",
diffs: [],
},
{
type: "tool",
id: "t3",
title: "read_bash",
kind: "other",
status: "running",
locations: [],
output: "",
diffs: [],
},
],
],
]),
});
store.openTaskInEditorLocation(task.id);
}, TASK);
const stream = page.locator("[class*='_stream_']:visible");
const summary = stream.locator("[class*='_processSummary_']").first();
await summary.click();
await expect(stream.getByText("Checking CI Status")).toBeVisible();
const layout = await stream.evaluate((root) => {
const summaryChevron = root.querySelector<SVGElement>("[class*='_processChevron_']")!.getBoundingClientRect();
const processBody = root.querySelector<HTMLElement>("[class*='_processBody_']")!.getBoundingClientRect();
const thoughtChevron = root.querySelector<SVGElement>("[class*='_thoughtChevron_']")!.getBoundingClientRect();
const toolRows = [...root.querySelectorAll<HTMLElement>("[class*='_tool_']")];
const expandableToolChevron = toolRows[0]!
.querySelector<SVGElement>("[class*='_toolChevron_']")!
.getBoundingClientRect();
const completedReadIcon = [...toolRows[1]!.querySelectorAll("svg")].at(-1)!.getBoundingClientRect();
const runningReadIcon = toolRows[2]!.querySelector("svg")!.getBoundingClientRect();
return {
summaryChevronCenter: summaryChevron.left + summaryChevron.width / 2,
guideLeft: processBody.left,
summaryToThoughtIndent: thoughtChevron.left - summaryChevron.left,
thoughtToToolIndent: expandableToolChevron.left - thoughtChevron.left,
iconLeftDiff: Math.abs(completedReadIcon.left - runningReadIcon.left),
};
});
// Guide line drops from the center of the process summary chevron.
expect(Math.abs(layout.guideLeft - layout.summaryChevronCenter)).toBeLessThanOrEqual(1.5);
// Thoughts indent clearly inside the process run, and tool calls indent under their thought step.
expect(layout.summaryToThoughtIndent).toBeGreaterThanOrEqual(20);
expect(layout.thoughtToToolIndent).toBeGreaterThanOrEqual(14);
// Output-less running tool rows align their kind icon with expandable tool rows.
expect(layout.iconLeftDiff).toBeLessThanOrEqual(1);
});
+43
Переглянути файл
@@ -0,0 +1,43 @@
import { EditorView } from "@codemirror/view";
import { commands, type InlayHint, type Range } from "../src/platform/ipc";
import { setInvokeRoute } from "../src/platform/tauriCore";
import { lspDoc } from "../src/editor/lsp/lsp";
import { inlayExtension } from "../src/editor/lsp/inlay";
import { lspTheme } from "../src/editor/lsp/theme";
const requests: { range: Range; resolve: (hints: InlayHint[]) => void }[] = [];
setInvokeRoute(() => null);
commands.lspInlayHints = async (_doc, range) =>
new Promise((resolve) => requests.push({ range, resolve: (data) => resolve({ status: "ok", data }) }));
const view = new EditorView({
parent: document.body,
doc: Array.from({ length: 2000 }, (_, i) => `let item${i} = value;`).join("\n"),
extensions: [
EditorView.theme({ "&": { height: "400px" }, ".cm-scroller": { overflow: "auto" } }),
lspTheme,
lspDoc.of({ doc: 1, path: "demo.rs", language: "rust", uiMode: "Rust", readOnly: false }),
inlayExtension(),
],
});
Object.assign(window, {
inlayTest: {
count: () => requests.length,
resolve(index: number) {
const request = requests[index]!;
request.resolve([
{
position: { line: request.range.start.line + 1, col: 4 },
label: `hint-${index}`,
kind: "type",
paddingLeft: false,
paddingRight: false,
tooltip: null,
parts: [],
},
]);
},
destroy: () => view.destroy(),
},
});
+9
Переглянути файл
@@ -0,0 +1,9 @@
<!doctype html>
<html>
<head>
<meta charset="UTF-8" />
</head>
<body>
<script type="module" src="./inlayRequests.fixture.ts"></script>
</body>
</html>
+18
Переглянути файл
@@ -0,0 +1,18 @@
import { expect, test } from "@playwright/test";
type Probe = { count(): number; resolve(index: number): void };
test("scrolling does not let an old viewport response replace current inlay hints", async ({ page }) => {
await page.goto("/e2e/inlayRequests.html");
const count = () => page.evaluate(() => (window as unknown as { inlayTest: Probe }).inlayTest.count());
await expect.poll(count).toBe(1);
await page.locator(".cm-scroller").evaluate((el) => {
el.scrollTop = 12000;
});
await expect.poll(count).toBe(2);
await page.evaluate(() => (window as unknown as { inlayTest: Probe }).inlayTest.resolve(1));
await expect(page.locator(".cm-lsp-inlay")).toHaveText("hint-1");
await page.evaluate(() => (window as unknown as { inlayTest: Probe }).inlayTest.resolve(0));
await page.waitForTimeout(500);
await expect(page.locator(".cm-lsp-inlay")).toHaveText("hint-1");
});
+6
Переглянути файл
@@ -0,0 +1,6 @@
id = "gherkin"
name = "Gherkin"
extensions = ["feature"]
line-comment = "#"
indent = { tab-size = 2, insert-spaces = true }
ui-mode = "Gherkin"
+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]
+3
Переглянути файл
@@ -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,
@@ -551,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,
+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(())
}
+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")]
+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"));
}
}
+2
Переглянути файл
@@ -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
@@ -535,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
+40 -2
Переглянути файл
@@ -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`.
@@ -1335,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.
@@ -1892,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,
@@ -2098,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 = {
@@ -2730,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,
@@ -3854,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. */
@@ -7957,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 },
};
@@ -9928,6 +9952,8 @@ export type Settings_Deserialize = {
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 } },
};
@@ -9998,6 +10024,8 @@ export type Settings_Serialize = {
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 } },
};
@@ -10146,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
+44
Переглянути файл
@@ -0,0 +1,44 @@
import { foldable } from "@codemirror/language";
import { EditorState } from "@codemirror/state";
import { describe, expect, it } from "vitest";
import { gherkinSupport } from "./gherkin";
const DOC = `@smoke
Feature: Checkout
As a shopper
Background:
Given a cart
Scenario Outline: pay with <method>
When I pay with "<method>":
| amount |
| 10 |
Then I see:
"""
Thanks
"""
Examples:
| method |
| card |
`;
describe("Gherkin", () => {
const state = EditorState.create({ doc: DOC, extensions: gherkinSupport() });
const foldAt = (lineText: string) => {
const line = state.doc.line(DOC.split("\n").findIndex((l) => l.trim() === lineText) + 1);
const r = foldable(state, line.from, line.to);
return r ? state.doc.lineAt(r.to).text.trim() : null;
};
it("folds sections, step arguments and doc strings by indentation", () => {
expect(foldAt("Feature: Checkout")).toBe("| card |");
expect(foldAt("Background:")).toBe("Given a cart");
expect(foldAt("Scenario Outline: pay with <method>")).toBe("| card |");
expect(foldAt('When I pay with "<method>":')).toBe("| 10 |");
expect(foldAt('"""')).toBe('"""');
expect(foldAt("Given a cart")).toBeNull();
expect(foldAt("@smoke")).toBeNull();
});
});
+51
Переглянути файл
@@ -0,0 +1,51 @@
/**
* Gherkin (`.feature`): the legacy-mode highlighting (keywords in every Gherkin
* language, tags, tables, doc strings, `<placeholders>`) plus folding of each
* section, step argument and doc string by indentation, as Cucumber's outline does.
*/
import { LanguageSupport, StreamLanguage, foldService } from "@codemirror/language";
import { gherkin } from "@codemirror/legacy-modes/mode/gherkin";
import type { EditorState } from "@codemirror/state";
export const gherkinLanguage = StreamLanguage.define(gherkin);
const indentOf = (text: string) => /^\s*/.exec(text)![0].replace(/\t/g, " ").length;
/**
* A header line — `Feature:`, `Scenario:`, a step ending in `:` before its table, an
* opening `"""` — folds the more indented lines below it, up to the last of them.
*/
export function gherkinFold(
state: EditorState,
lineStart: number,
lineEnd: number,
): { from: number; to: number } | null {
const doc = state.doc;
const header = doc.lineAt(lineStart);
const text = header.text.trim();
if (!text || text.startsWith("#") || text.startsWith("|") || text.startsWith("@")) return null;
const docString = /^("""|```)/.exec(text);
if (docString) {
// The matching closing fence, at any indentation.
for (let n = header.number + 1; n <= doc.lines; n++) {
const line = doc.line(n);
if (line.text.trim().startsWith(docString[1]!))
return n > header.number + 1 ? { from: lineEnd, to: line.to } : null;
}
return null;
}
if (!text.endsWith(":") && !/^[^\s:]+(\s[^\s:]+)*:\s/.test(text)) return null;
const own = indentOf(header.text);
let last = header.number;
for (let n = header.number + 1; n <= doc.lines; n++) {
const line = doc.line(n);
if (!line.text.trim()) continue;
if (indentOf(line.text) <= own && !line.text.trim().startsWith("#")) break;
last = n;
}
return last > header.number ? { from: lineEnd, to: doc.line(last).to } : null;
}
export function gherkinSupport(): LanguageSupport {
return new LanguageSupport(gherkinLanguage, [foldService.of(gherkinFold)]);
}
+5
Переглянути файл
@@ -92,6 +92,11 @@ const OWN_MODES = [
extensions: ["rst"],
load: () => import("./restructuredtext").then((m) => new LanguageSupport(m.restructuredtextLanguage)),
}),
LanguageDescription.of({
name: "Gherkin",
extensions: ["feature"],
load: () => import("./gherkin").then((m) => m.gherkinSupport()),
}),
LanguageDescription.of({
name: "Log",
extensions: ["log"],
+16 -5
Переглянути файл
@@ -159,7 +159,8 @@ function shownKind(kind: InlayHint["kind"]): boolean {
const inlayPlugin = ViewPlugin.fromClass(
class {
private refresh = debounce(() => void this.run(), 400);
private generation = 0;
private schedule = debounce(() => void this.run(), 400);
private unsubscribe: () => void;
private offReady: () => void;
private offSettled: () => void;
@@ -185,6 +186,10 @@ const inlayPlugin = ViewPlugin.fromClass(
update(u: ViewUpdate) {
if (u.docChanged || u.viewportChanged || (this.skipped && shownAgain(u))) this.refresh();
}
private refresh() {
this.generation++;
this.schedule();
}
async run() {
const view = this.view;
this.skipped = !view.dom.isConnected;
@@ -204,12 +209,17 @@ const inlayPlugin = ViewPlugin.fromClass(
return;
}
const state = view.state;
const generation = this.generation;
const wanted = () => generation === this.generation && view.state.doc === state.doc;
const { from, to } = view.viewport;
const first = state.doc.lineAt(from).from;
const last = state.doc.lineAt(to).to;
try {
const hints = await lspRequest(() => commands.lspInlayHints(doc.doc, offsetsToRange(state.doc, first, last)));
if (view.state.doc !== state.doc) return this.refresh();
const hints = await lspRequest(
() => commands.lspInlayHints(doc.doc, offsetsToRange(state.doc, first, last)),
wanted,
);
if (!wanted()) return;
const fresh = hints.filter((h) => shownKind(h.kind));
// A busy server (indexing, loading a build) can answer with nothing: keep the
// hints shown until it settles, instead of blinking them away and reflowing
@@ -220,11 +230,12 @@ const inlayPlugin = ViewPlugin.fromClass(
effects: setInlays.of(inlayDecorations(view, fresh)),
});
} catch (e) {
if (isUnavailable(e)) inlayBackoff.mark(doc.doc);
if (wanted() && isUnavailable(e)) inlayBackoff.mark(doc.doc);
}
}
destroy() {
this.refresh.cancel();
this.generation++;
this.schedule.cancel();
this.unsubscribe();
this.offReady();
this.offSettled();
+184
Переглянути файл
@@ -0,0 +1,184 @@
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { _addEditor, _removeEditor, documentSynced, viewShown } from "@/editor/api";
import type { InlayHint } from "@/bindings";
const ipc = vi.hoisted(() => ({ lspInlayHints: vi.fn() }));
vi.mock("@/platform/ipc", async (orig) => {
const real = await orig<typeof import("@/platform/ipc")>();
return { ...real, isTauri: () => true, commands: { ...real.commands, ...ipc } };
});
const { inlayExtension } = await import("./inlay");
const { lspDoc } = await import("./lsp");
const { useProject } = await import("@/platform/project");
const { emitLocalIdeEvent } = await import("@/platform/ipc");
const views: EditorView[] = [];
const ok = (label: string) => ({
status: "ok" as const,
data: [
{
position: { line: 0, col: 5 },
label,
kind: "type",
parts: [],
paddingLeft: false,
paddingRight: false,
tooltip: null,
},
] as InlayHint[],
});
function deferred<T>() {
let resolve!: (value: T) => void;
const promise = new Promise<T>((r) => (resolve = r));
return { promise, resolve };
}
const ctx = { doc: 71, path: "/p/a.rs", language: "rust", uiMode: "Rust", readOnly: false };
function editor(sync?: () => Promise<void>) {
const view = new EditorView({
state: EditorState.create({
doc: "let x = 1;",
extensions: [lspDoc.of(ctx), ...(sync ? [documentSynced.of(sync)] : []), inlayExtension()],
}),
parent: document.body,
});
views.push(view);
return view;
}
const labels = (view: EditorView) => [...view.dom.querySelectorAll(".cm-lsp-inlay")].map((e) => e.textContent);
beforeEach(() => {
vi.useFakeTimers();
ipc.lspInlayHints.mockReset().mockResolvedValue(ok("current"));
useProject.setState({ settings: { editor: { inlayHints: true } } as never });
});
afterEach(() => {
views.splice(0).forEach((v) => v.destroy());
useProject.setState({ settings: null });
vi.useRealTimers();
});
describe("inlay request lifetime", () => {
it("does not restore hints after they were disabled", async () => {
const old = deferred<ReturnType<typeof ok>>();
ipc.lspInlayHints.mockReturnValueOnce(old.promise);
const view = editor();
await vi.advanceTimersByTimeAsync(400);
useProject.setState({ settings: { editor: { inlayHints: false } } as never });
await vi.advanceTimersByTimeAsync(400);
old.resolve(ok("stale"));
await vi.advanceTimersByTimeAsync(1);
expect(labels(view)).toEqual([]);
});
it("does not overwrite a newer server refresh with an older response", async () => {
const old = deferred<ReturnType<typeof ok>>();
ipc.lspInlayHints.mockReturnValueOnce(old.promise);
const view = editor();
await vi.advanceTimersByTimeAsync(400);
emitLocalIdeEvent({ type: "lspRefresh", kind: "inlayHints", server: 1 });
await vi.advanceTimersByTimeAsync(400);
expect(labels(view)).toEqual(["current"]);
old.resolve(ok("stale"));
await vi.advanceTimersByTimeAsync(1);
expect(labels(view)).toEqual(["current"]);
});
});
describe("obsolete inlay work", () => {
it("invalidates immediately, before the next debounced request starts", async () => {
const old = deferred<ReturnType<typeof ok>>();
ipc.lspInlayHints.mockReturnValueOnce(old.promise);
const view = editor();
await vi.advanceTimersByTimeAsync(400);
emitLocalIdeEvent({ type: "lspRefresh", kind: "inlayHints", server: 1 });
old.resolve(ok("stale"));
await vi.advanceTimersByTimeAsync(1);
expect(labels(view)).toEqual([]);
await vi.advanceTimersByTimeAsync(399);
expect(labels(view)).toEqual(["current"]);
});
it("does not dispatch a response into a destroyed editor", async () => {
const old = deferred<ReturnType<typeof ok>>();
ipc.lspInlayHints.mockReturnValueOnce(old.promise);
const view = editor();
await vi.advanceTimersByTimeAsync(400);
view.destroy();
views.splice(views.indexOf(view), 1);
const dispatch = vi.spyOn(view, "dispatch");
old.resolve(ok("stale"));
await vi.advanceTimersByTimeAsync(400);
expect(dispatch).not.toHaveBeenCalled();
});
it("does not send obsolete requests after waiting for document synchronization", async () => {
const synced = deferred<void>();
const view = editor(() => synced.promise);
const handle = { view, ctx };
_addEditor(handle);
try {
await vi.advanceTimersByTimeAsync(400);
expect(ipc.lspInlayHints).not.toHaveBeenCalled();
view.destroy();
views.splice(views.indexOf(view), 1);
synced.resolve();
await vi.advanceTimersByTimeAsync(400);
expect(ipc.lspInlayHints).not.toHaveBeenCalled();
} finally {
_removeEditor(handle);
}
});
});
describe("retained editors", () => {
it("keeps an in-flight response when the editor is detached then shown again", async () => {
const pending = deferred<ReturnType<typeof ok>>();
ipc.lspInlayHints.mockReturnValueOnce(pending.promise);
const view = editor();
await vi.advanceTimersByTimeAsync(400);
view.dom.remove();
pending.resolve(ok("retained"));
await vi.advanceTimersByTimeAsync(1);
document.body.append(view.dom);
view.dispatch({ effects: viewShown.of(null) });
await vi.advanceTimersByTimeAsync(400);
expect(labels(view)).toEqual(["retained"]);
});
it("keeps work waiting for document synchronization when detached then shown again", async () => {
const synced = deferred<void>();
const view = editor(() => synced.promise);
const handle = { view, ctx };
_addEditor(handle);
try {
await vi.advanceTimersByTimeAsync(400);
expect(ipc.lspInlayHints).not.toHaveBeenCalled();
view.dom.remove();
synced.resolve();
await vi.advanceTimersByTimeAsync(1);
document.body.append(view.dom);
view.dispatch({ effects: viewShown.of(null) });
await vi.advanceTimersByTimeAsync(400);
expect(labels(view)).toEqual(["current"]);
} finally {
_removeEditor(handle);
}
});
});
describe("settled refresh request lifetime", () => {
it.each([true, false])("rejects old busy answers after a settled refresh (empty=%s)", async (empty) => {
const view = editor();
await vi.advanceTimersByTimeAsync(400);
expect(labels(view)).toEqual(["current"]);
const old = deferred<ReturnType<typeof ok>>();
ipc.lspInlayHints.mockReturnValueOnce(old.promise);
emitLocalIdeEvent({ type: "languageServer", server: 91, name: "rust-analyzer", status: "busy", message: null });
emitLocalIdeEvent({ type: "lspRefresh", kind: "inlayHints", server: 91 });
await vi.advanceTimersByTimeAsync(1600);
const settled = empty ? { status: "ok" as const, data: [] } : ok("settled");
ipc.lspInlayHints.mockResolvedValue(settled);
emitLocalIdeEvent({ type: "languageServer", server: 91, name: "rust-analyzer", status: "ready", message: null });
// Settling invalidates immediately, not only after the debounce delay.
old.resolve(ok("stale busy"));
await vi.advanceTimersByTimeAsync(1);
expect(labels(view)).toEqual(["current"]);
await vi.advanceTimersByTimeAsync(399);
expect(labels(view)).toEqual(empty ? [] : ["settled"]);
});
});
+31 -8
Переглянути файл
@@ -404,6 +404,13 @@
.agentName {
display: none;
}
.processBody,
.turnBody {
padding-left: var(--space-2);
}
.processBody > .thoughtEntry ~ .toolEntry {
padding-left: var(--space-3);
}
}
.messageActions {
display: inline-flex;
@@ -771,6 +778,10 @@
margin-bottom: 0;
}
.thoughtEntry,
.toolEntry {
min-width: 0;
}
.thought summary,
.toolDetails > summary {
cursor: pointer;
@@ -783,15 +794,18 @@
.thought summary {
display: flex;
align-items: center;
gap: var(--space-1);
gap: var(--space-1-5);
min-width: 0;
min-height: var(--h-row);
padding: 0 calc(var(--space-2) / 2);
border-radius: var(--radius-row);
color: var(--fg-muted);
font-size: var(--agent-fs-small, var(--fs-small));
-webkit-user-select: none;
user-select: none;
}
.thought summary:hover {
background: var(--bg-hover);
color: var(--fg);
}
.thoughtChevron {
@@ -807,7 +821,9 @@
transform: rotate(90deg);
}
.thoughtBody {
margin-top: var(--space-2);
margin: var(--space-1-5) 0 var(--space-1) 10px;
padding-left: var(--space-3);
border-left: 1px solid var(--border);
color: var(--fg-secondary);
}
.thoughtText {
@@ -821,7 +837,7 @@
.tool {
display: flex;
align-items: center;
gap: var(--space-2);
gap: var(--space-1-5);
min-width: 0;
box-sizing: border-box;
min-height: var(--h-row);
@@ -848,6 +864,10 @@
.toolChevron {
flex: none;
}
.toolChevronSpacer {
width: 12px;
flex: none;
}
.toolDetails[open] > summary .toolChevron {
transform: rotate(90deg);
}
@@ -927,12 +947,15 @@
gap: var(--space-0-5);
max-height: calc(var(--h-row) * 16);
overflow-y: auto;
margin-top: 2px;
padding-left: 10px;
margin: 2px 0 0 10px;
padding-left: var(--space-3);
border-left: 1px solid var(--border);
}
.processBody > .thoughtEntry ~ .toolEntry {
padding-left: var(--space-4);
}
.output {
margin: 4px 0 0;
margin: 4px 0 4px 22px;
max-height: 240px;
overflow: auto;
padding: 8px 10px;
@@ -1828,8 +1851,8 @@
display: flex;
flex-direction: column;
gap: var(--space-2);
margin-top: 2px;
padding-left: 10px;
margin: 2px 0 0 10px;
padding-left: var(--space-3);
border-left: 1px solid var(--border);
}
+7 -4
Переглянути файл
@@ -1426,7 +1426,7 @@ function ThoughtEntry({
if (working && open) onDiagramDrawn();
}, [shown, working, open, onDiagramDrawn]);
return (
<div className={styles.process}>
<div className={clsx(styles.process, styles.thoughtEntry)}>
<Fold
className={clsx(styles.thought, thinking === "auto" && working && styles.thoughtLive)}
open={open}
@@ -2072,12 +2072,15 @@ const ToolEntry = memo(function ToolEntry({
);
if (!entry.output)
return (
<div className={styles.process}>
<div className={styles.tool}>{head}</div>
<div className={clsx(styles.process, styles.toolEntry)}>
<div className={styles.tool}>
<span className={styles.toolChevronSpacer} aria-hidden="true" />
{head}
</div>
</div>
);
return (
<div className={styles.process}>
<div className={clsx(styles.process, styles.toolEntry)}>
<Fold
className={styles.toolDetails}
open={liveTool(entry) || expandToolOutput}
-11
Переглянути файл
@@ -35,7 +35,6 @@ import {
import {
age,
appendEntry,
attentionChange,
branchLabel,
entriesKey,
findSubagent,
@@ -447,16 +446,6 @@ describe("agents model", () => {
expect(appendEntry([u, a], 2, 0, "x")).toBeNull();
});
it("notifies on finish, failure and questions only", () => {
expect(attentionChange("running", "ready")).toBe("finished");
expect(attentionChange("running", "failed")).toBe("failed");
expect(attentionChange("running", "limited")).toBe("failed");
expect(attentionChange("running", "needsInput")).toBe("input");
expect(attentionChange("needsInput", "running")).toBeNull();
expect(attentionChange("ready", "archived")).toBeNull();
expect(attentionChange(undefined, "ready")).toBeNull();
});
it("finds subagent cards and keys their conversations apart", () => {
const card: SubagentEntry = {
type: "subagent",
-13
Переглянути файл
@@ -242,16 +242,3 @@ export function age(ms: number, now = Date.now()): string {
if (h < 24) return `${h}h`;
return `${Math.round(h / 24)}d`;
}
/** The status change worth a notification, if any. */
export function attentionChange(
prev: AgentStatus | undefined,
next: AgentStatus,
): "finished" | "failed" | "input" | null {
if (prev === next || prev === undefined) return null;
if (next === "needsInput") return "input";
if (!isBusy(prev)) return null;
if (next === "ready") return "finished";
if (next === "failed" || next === "limited") return "failed";
return null;
}
+19 -16
Переглянути файл
@@ -53,7 +53,6 @@ import {
SESSION_KIND,
TOOL_WINDOW,
appendEntry,
attentionChange,
entriesKey,
isBusy,
sessionKey,
@@ -553,14 +552,17 @@ function onEvent(e: AgentEvent) {
useAgents.setState({ tasks: new Map(s.tasks).set(e.task.id, e.task) });
if (prev && (prev.title !== e.task.title || prev.status !== e.task.status)) notifyTabTitlesChanged();
if (e.task.status === "archived") setUnread(e.task.id, false);
else if (attentionChange(prev?.status, e.task.status)) markUnread(e.task.id);
notifyChange(prev, e.task);
if (prev?.status !== e.task.status && !isBusy(e.task.status)) {
void refreshChanges(e.task.id);
void refreshProviders();
}
break;
}
case "attention": {
markUnread(e.task);
notifyAttention(e.task, e.reason);
break;
}
case "removed": {
const tasks = new Map(s.tasks);
tasks.delete(e.id);
@@ -633,27 +635,28 @@ function onEvent(e: AgentEvent) {
}
}
function notifyChange(prev: AgentTask | undefined, task: AgentTask) {
const change = attentionChange(prev?.status, task.status);
if (!change) return;
if (viewing(task.id)) return;
/** In-app balloon for an Attention event; OS delivery goes through the general balloon path. */
function notifyAttention(taskId: string, reason: "finished" | "input" | "failed") {
if (viewing(taskId)) return;
const task = useAgents.getState().tasks.get(taskId);
const title = task?.title ?? "Agent";
const body =
change === "input"
reason === "input"
? "Waiting for your answer"
: change === "failed"
? (task.error ?? "The agent stopped")
: reason === "failed"
? (task?.error ?? "The agent stopped")
: "Finished";
notifications().notify({
level: change === "failed" ? "error" : "info",
title: task.title,
level: reason === "failed" ? "error" : "info",
title,
body,
key: `agent:${task.id}`,
key: `agent:${taskId}`,
group: "tools",
sticky: change !== "finished",
sticky: reason !== "finished",
actions: [
{
label: change === "finished" ? "Review" : "Open",
run: () => openTask(task.id),
label: reason === "finished" ? "Review" : "Open",
run: () => openTask(taskId),
},
],
});
+15 -2
Переглянути файл
@@ -163,16 +163,28 @@ describe("agent unread activity", () => {
expect([...useAgents.getState().unread]).toEqual(["one"]);
});
it.each(["ready", "needsInput", "failed", "limited"] as const)("marks background %s transitions unread", (status) => {
it.each([
["finished", "ready"],
["input", "needsInput"],
["failed", "failed"],
["failed", "limited"],
] as const)("marks background attention %s unread", (reason, status) => {
emit({ type: "task", task: task("one", status) });
emit({ type: "attention", task: "one", eventId: `one:${reason}:1`, reason });
expect(useAgents.getState().unread.has("one")).toBe(true);
expect(backend.notify).toHaveBeenCalledTimes(1);
show();
emit({ type: "task", task: task("one", status) });
emit({ type: "attention", task: "one", eventId: `one:${reason}:2`, reason });
expect(useAgents.getState().unread.size).toBe(0);
expect(backend.notify).toHaveBeenCalledTimes(1);
});
it("does not notify from status alone once Attention exists", () => {
emit({ type: "task", task: task("one", "ready") });
expect(backend.notify).not.toHaveBeenCalled();
expect(useAgents.getState().unread.has("one")).toBe(false);
});
it("keeps the latest usage limits per provider without marking anything unread", () => {
const fiveHour = (usedPercent: number) => [{ window: "five_hour", usedPercent, resetsMs: null }];
emit({ type: "limits", provider: "claude", limits: fiveHour(10) });
@@ -258,6 +270,7 @@ describe("agent unread activity", () => {
describe("agent unread indicators", () => {
it("shows a dot on the task and a clickable status count even when all tasks are idle", () => {
emit({ type: "task", task: task("one", "ready") });
emit({ type: "attention", task: "one", eventId: "one:finished:1", reason: "finished" });
render(
<>
<AgentsView />
+38 -15
Переглянути файл
@@ -11,7 +11,10 @@ const component = (name: string, options: Record<string, string>) =>
.map(([k, v]) => `<option name="${k}" value="${v}" />`)
.join("")}</component></application>`;
const editor = { fontSize: 13, customSchemes: {}, colorOverrides: {} };
const editor = { fontFamily: "JetBrains Mono", fontSize: 13, customSchemes: {}, colorOverrides: {} };
/** JetBrains Maple Mono's metrics (ascent 1.02em, descent 0.3em), for any family. */
const fontHeight = (_family: string, size: number) => Math.ceil(size * 1.02) + Math.ceil(size * 0.3);
/** A WebStorm export, trimmed to what the import reads. */
const webstorm = {
@@ -51,8 +54,8 @@ const webstorm = {
};
describe("planJetBrainsImport", () => {
it("maps a WebStorm export to the settings it has, and lists what is left out", () => {
const plan = planJetBrainsImport(webstorm, editor);
it("maps a WebStorm export to the settings it has, and lists what is left out", async () => {
const plan = await planJetBrainsImport(webstorm, editor, fontHeight);
const writes = Object.fromEntries(plan.writes);
const schemes = writes["editor.customSchemes"] as Record<string, { name: string; parent: string }>;
const [id, scheme] = Object.entries(schemes)[0]!;
@@ -62,6 +65,8 @@ describe("planJetBrainsImport", () => {
"editor.colorScheme": id,
"editor.fontFamily": "JetBrains Maple Mono",
"editor.fontSize": 17,
// (18 + 6) × the default spacing 1.2, rounded up, as WebStorm draws it.
"editor.lineHeight": 29,
"editor.ligatures": true,
"files.trimTrailingWhitespace": true,
"editor.general.stripTrailingScope": "all",
@@ -83,8 +88,8 @@ describe("planJetBrainsImport", () => {
expect(plan.invalid).toEqual([]);
});
it("writes only the keys present, and derives the line height from IDEA's spacing", () => {
const plan = planJetBrainsImport(
it("writes only the keys present, and derives the line height from IDEA's spacing", async () => {
const plan = await planJetBrainsImport(
{
entries: [],
files: {
@@ -98,32 +103,50 @@ describe("planJetBrainsImport", () => {
},
},
editor,
fontHeight,
);
expect(plan.writes).toEqual([
["editor.lineHeight", 20],
// (14 + 4) × 1.5
["editor.lineHeight", 27],
["files.trimTrailingWhitespace", false],
["editor.softWrap", true],
]);
expect(plan.skipped).toEqual([]);
});
it("re-importing replaces the earlier copy of a scheme and drops its edits", () => {
const first = Object.fromEntries(planJetBrainsImport(webstorm, editor).writes);
it("re-importing replaces the earlier copy of a scheme and drops its edits", async () => {
const first = Object.fromEntries((await planJetBrainsImport(webstorm, editor, fontHeight)).writes);
const customs = first["editor.customSchemes"] as typeof editor.customSchemes;
const [id] = Object.keys(customs);
const again = planJetBrainsImport(webstorm, {
...editor,
customSchemes: customs,
colorOverrides: { [id!]: { keyword: { bold: true } }, other: {} },
});
const again = await planJetBrainsImport(
webstorm,
{
...editor,
customSchemes: customs,
colorOverrides: { [id!]: { keyword: { bold: true } }, other: {} },
},
fontHeight,
);
const writes = Object.fromEntries(again.writes);
expect(Object.keys(writes["editor.customSchemes"] as object)).toEqual([id]);
expect(writes["editor.colorOverrides"]).toEqual({ other: {} });
expect(writes["editor.colorScheme"]).toBe(id);
});
it("skips colour schemes that cannot be read", () => {
const plan = planJetBrainsImport({ entries: [], files: { "colors/broken.icls": "<nope" } }, editor);
it("falls back to the font size when the font cannot be measured", async () => {
const plan = await planJetBrainsImport(
{ entries: [], files: { "options/editor-font.xml": component("DefaultFont", { FONT_SIZE: "20" }) } },
editor,
() => undefined,
);
expect(plan.writes).toEqual([
["editor.fontSize", 20],
["editor.lineHeight", 29],
]);
});
it("skips colour schemes that cannot be read", async () => {
const plan = await planJetBrainsImport({ entries: [], files: { "colors/broken.icls": "<nope" } }, editor);
expect(plan.invalid).toEqual(["broken.icls"]);
expect(plan.writes).toEqual([]);
});
+4 -1
Переглянути файл
@@ -4,7 +4,7 @@ import { act, fireEvent, render, screen } from "@testing-library/react";
const read = vi.fn();
const set = vi.fn();
const notify = vi.fn();
const editor = { fontSize: 13, customSchemes: {}, colorOverrides: {} };
const editor = { fontFamily: "JetBrains Mono", fontSize: 13, customSchemes: {}, colorOverrides: {} };
vi.mock("@/platform/ipc", async (original) => {
const actual = await original<typeof import("@/platform/ipc")>();
@@ -44,6 +44,8 @@ beforeEach(() => {
},
});
set.mockResolvedValue({ status: "ok", data: { editor } });
// jsdom has no canvas: the import falls back to the font size for the line height.
vi.spyOn(HTMLCanvasElement.prototype, "getContext").mockReturnValue(null);
});
it.each(["Cancel", "Import"])("confirms folder settings before applying them: %s", async (button) => {
@@ -78,6 +80,7 @@ it.each(["Cancel", "Import"])("confirms folder settings before applying them: %s
"editor.colorScheme": id,
"editor.fontFamily": "Monaco",
"editor.fontSize": 17,
"editor.lineHeight": 25,
});
expect(notify).toHaveBeenCalledWith(expect.objectContaining({ title: "Settings imported" }));
}
+44 -4
Переглянути файл
@@ -8,6 +8,7 @@
import { Fragment } from "react";
import type { JetBrainsSettings } from "@/bindings";
import { customSchemes } from "@/platform/colorScheme";
import { createFontProbeCanvas, fontsLoaded, monoFontFamily } from "@/platform/fonts";
import { tx } from "@/platform/i18n";
import { importScheme, parseIcls } from "@/platform/icls";
import { call, commands } from "@/platform/ipc";
@@ -28,6 +29,7 @@ export interface JetBrainsImportPlan {
}
interface EditorState {
fontFamily: string;
fontSize: number | null;
customSchemes: unknown;
colorOverrides: Record<string, unknown>;
@@ -63,7 +65,39 @@ const num = (v: string | undefined) => {
const onOff = (v: boolean) => (v ? tx("On") : tx("Off"));
export function planJetBrainsImport(bundle: JetBrainsSettings, editor: EditorState): JetBrainsImportPlan {
/** IDEA's `LINE_SPACING` when the export leaves it out. */
const DEFAULT_LINE_SPACING = 1.2;
/** The font's own line height in px, as IDEA's editor takes it from Java's FontMetrics. */
export type FontHeight = (family: string, size: number) => Promise<number | undefined> | number | undefined;
/** WebKit reports whole-pixel metrics; measured this large, they keep the font's fractions. */
const PROBE_SIZE = 1000;
async function measuredFontHeight(family: string, size: number): Promise<number | undefined> {
// The editor's own stack: WKWebView draws an installed font only through its loaded alias.
const stack = monoFontFamily(family);
await fontsLoaded(stack, size);
const canvas = createFontProbeCanvas();
try {
const ctx = canvas.getContext("2d");
if (!ctx) return undefined;
ctx.font = `${PROBE_SIZE}px ${stack}`;
const m = ctx.measureText("M");
// Java rounds the ascent and the descent up separately (anything past .05 of a pixel).
const px = (v: number) => Math.floor((v / PROBE_SIZE) * size + 0.95);
const h = px(m.fontBoundingBoxAscent) + px(m.fontBoundingBoxDescent);
return Number.isFinite(h) && h > 0 ? h : undefined;
} finally {
canvas.remove();
}
}
export async function planJetBrainsImport(
bundle: JetBrainsSettings,
editor: EditorState,
fontHeight: FontHeight = measuredFontHeight,
): Promise<JetBrainsImportPlan> {
const plan: JetBrainsImportPlan = { writes: [], rows: [], skipped: [], invalid: [] };
const add = (key: string, value: string | number | boolean | undefined, label: string, shown?: string) => {
if (value === undefined) return;
@@ -101,12 +135,18 @@ export function planJetBrainsImport(bundle: JetBrainsSettings, editor: EditorSta
}
const font = options(bundle.files["options/editor-font.xml"], "DefaultFont");
add("editor.fontFamily", font.get("FONT_FAMILY")?.trim() || undefined, tx("Font"));
const family = font.get("FONT_FAMILY")?.trim() || undefined;
add("editor.fontFamily", family, tx("Font"));
const size = num(font.get("FONT_SIZE"));
add("editor.fontSize", size, tx("Size"));
const spacing = num(font.get("LINE_SPACING"));
// IDEA spaces lines by the font's own height, not its size, so a tall font keeps its
// spacing; and the default spacing still applies when only the font changed.
const base = size ?? editor.fontSize;
add("editor.lineHeight", spacing && base ? Math.round(base * spacing) : undefined, tx("Line height"));
if (base && (family || size || spacing)) {
const natural = (await fontHeight(family ?? editor.fontFamily, base)) ?? base * DEFAULT_LINE_SPACING;
add("editor.lineHeight", Math.ceil(natural * (spacing ?? DEFAULT_LINE_SPACING)), tx("Line height"));
}
add("editor.ligatures", bool(font.get("USE_LIGATURES")), tx("Enable ligatures"));
const ed = options(bundle.files["options/editor.xml"], "EditorSettings");
@@ -174,7 +214,7 @@ function Summary({ plan }: { plan: JetBrainsImportPlan }) {
export async function importJetBrainsSettings(path: string) {
const bundle = await call(commands.settingsReadJetbrains(path));
const { editor } = await commands.settingsGetGlobal();
const plan = planJetBrainsImport(bundle, editor);
const plan = await planJetBrainsImport(bundle, editor);
if (!plan.writes.length) {
notifications().notify({
level: "warning",
+32 -23
Переглянути файл
@@ -251,6 +251,8 @@
min-height: 0;
display: flex;
flex-direction: column;
/* Data source colours are stronger than file colours. */
--row-tint-strength: var(--tint-strength);
}
.treeHost > * {
flex: 1;
@@ -262,29 +264,6 @@
gap: var(--space-1-5);
min-width: 0;
}
/* The whole tree row, indent included, so a coloured source and its children form one band. */
.tintedRow:not([aria-selected="true"]):not(:hover) {
border-radius: 0;
background: color-mix(in srgb, var(--db-tint) var(--tint-strength), transparent);
}
.tintRed {
--db-tint: var(--db-color-red);
}
.tintOrange {
--db-tint: var(--db-color-orange);
}
.tintYellow {
--db-tint: var(--db-color-yellow);
}
.tintGreen {
--db-tint: var(--db-color-green);
}
.tintBlue {
--db-tint: var(--db-color-blue);
}
.tintViolet {
--db-tint: var(--db-color-violet);
}
.nodeLabel {
overflow: hidden;
text-overflow: ellipsis;
@@ -1407,3 +1386,33 @@
color: inherit;
cursor: default;
}
/* In-Editor Results: a result set under its statement in the console. */
:global(.cm-openidea-db-inline) {
padding: var(--space-1) 0 var(--space-2);
cursor: default;
}
.inlineResult {
position: relative;
display: flex;
flex-direction: column;
max-width: 100%;
border: 1px solid var(--border);
border-radius: var(--radius-control);
overflow: hidden;
background: var(--bg-editor);
font-family: var(--font-ui);
font-size: var(--fs-ui);
line-height: normal;
white-space: normal;
}
.inlineResult > :first-child {
flex: 1;
min-height: 0;
}
.inlineResize {
position: absolute;
inset: auto 0 0;
height: 5px;
cursor: row-resize;
}
+5 -5
Переглянути файл
@@ -8,7 +8,6 @@ import { tablesKey, useDatabase } from "./store";
import { tableInput } from "./tableInput";
import { useEditorRegistry } from "@/editor/api";
import { provideEditorService, provideToolWindowService, type EditorInput } from "@/workbench/contributions";
import styles from "./Database.module.css";
vi.mock("@tanstack/react-virtual", () => ({
useVirtualizer: ({ count }: { count: number }) => ({
@@ -195,9 +194,10 @@ describe("data source colour", () => {
});
render(<DatabaseView />);
const tree = within(screen.getByRole("tree", { name: "Data sources" }));
for (const name of ["PostgreSQL", "public", "routines", "refresh_data"]) {
expect(tree.getByText(name).closest('[role="treeitem"]')).toHaveClass(styles.tintedRow!, styles.tintRed!);
}
expect(tree.getByText("SQLite").closest('[role="treeitem"]')).not.toHaveClass(styles.tintedRow!);
const tint = (name: string) =>
tree.getByText(name).closest<HTMLElement>('[role="treeitem"]')!.style.getPropertyValue("--row-tint");
for (const name of ["PostgreSQL", "public", "routines", "refresh_data"])
expect(tint(name)).toBe("var(--db-color-red)");
expect(tint("SQLite")).toBe("");
});
});
+3 -12
Переглянути файл
@@ -6,7 +6,7 @@
* source to open its query console.
*/
import { useEffect, useMemo, useRef } from "react";
import type { DbColor, DbDatabases, DbTableDetails } from "@/platform/ipc";
import type { DbDatabases, DbTableDetails } from "@/platform/ipc";
import { executeAction } from "@/platform/actions";
import { shortcutLabel } from "@/platform/keymap";
import {
@@ -55,15 +55,6 @@ import styles from "./Database.module.css";
import { tx } from "@/platform/i18n";
import { databaseRequest } from "./requests";
const ROW_TINTS: Record<DbColor, string | undefined> = {
red: styles.tintRed,
orange: styles.tintOrange,
yellow: styles.tintYellow,
green: styles.tintGreen,
blue: styles.tintBlue,
violet: styles.tintViolet,
};
const GROUP_LABELS: Record<Group, string> = {
columns: "columns",
keys: "keys",
@@ -525,11 +516,11 @@ export function DatabaseView() {
getIcon={(n) => icon(n)}
getDetail={detail}
getColor={(n) => (n.kind === "message" && n.error ? "var(--danger)" : undefined)}
rowClassName={(n) => {
rowTint={(n) => {
// IDEA tints every row of a coloured data source across its full width and height.
const target = nodeTarget(n);
const color = target ? sourceOf(target)?.color : null;
return color ? `${styles.tintedRow} ${ROW_TINTS[color]}` : undefined;
return color ? `var(--db-color-${color})` : undefined;
}}
speedSearchField
renderNode={(n: Node, state) => {
+2
Переглянути файл
@@ -13,6 +13,7 @@ const ObjectDialogs = lazyComponent(() => import("./ObjectDialogs").then((m) =>
const ExportDialog = lazyComponent(() => import("./ExportDialog").then((m) => m.ExportDialog));
const HistoryDialog = lazyComponent(() => import("./DataDialogs").then((m) => m.HistoryDialog));
const ImportDialog = lazyComponent(() => import("./DataDialogs").then((m) => m.ImportDialog));
const SchemaCompareDialog = lazyComponent(() => import("./SchemaCompareDialog").then((m) => m.SchemaCompareDialog));
function PasswordDialog({ source, resolve }: { source: DataSource; resolve: (ok: boolean) => void }) {
const [password, setPassword] = useState("");
@@ -185,6 +186,7 @@ export function DatabaseDialogs() {
if (dialog.kind === "params") return <ParamsDialog names={dialog.names} resolve={dialog.resolve} />;
if (dialog.kind === "export")
return <ExportDialog data={dialog.data} source={dialog.source} initialFormat={dialog.format} />;
if (dialog.kind === "compareSchemas") return <SchemaCompareDialog initial={dialog.source} />;
if (dialog.kind === "history") return <HistoryDialog key={dialog.id} id={dialog.id} path={dialog.path} />;
if (dialog.kind === "import")
return (
+4 -2
Переглянути файл
@@ -254,7 +254,8 @@ function setSubmittingResult(result: DbQueryResult, on: boolean) {
notifyResults();
}
function Result({ tab }: { tab: ResultTab }) {
/** A result set's toolbar, grid and pager; `onClose` makes it an in-editor result (closed in place, not pinned). */
export function Result({ tab, onClose }: { tab: ResultTab; onClose?: () => void }) {
const [view, setView] = useState<"table" | "chart">("table");
const [panel, setPanel] = useState<DataPanel | null>(null);
const [searchOpen, setSearchOpen] = useState(false);
@@ -516,7 +517,7 @@ function Result({ tab }: { tab: ResultTab }) {
disabled={busy}
onClick={() => void rerunResult(tab.id)}
/>
<PinButton tab={tab} />
{!onClose && <PinButton tab={tab} />}
{view === "table" && (
<IconButton
icon="search"
@@ -568,6 +569,7 @@ function Result({ tab }: { tab: ResultTab }) {
onClick={(e) => showExport({ x: e.clientX, y: e.clientY })}
/>
{view === "table" && <PanelToggle panel={panel} onChange={setPanel} />}
{onClose && <IconButton icon="close" title="Close" onClick={onClose} />}
</Toolbar>
{view === "chart" ? (
<div className={styles.fill}>
+91
Переглянути файл
@@ -0,0 +1,91 @@
.body {
display: flex;
flex-direction: column;
gap: var(--space-2);
height: 560px;
padding: 14px;
}
.pickers {
display: flex;
align-items: center;
gap: var(--space-2);
flex-wrap: wrap;
}
.side {
display: flex;
align-items: center;
gap: var(--space-1);
}
.sideLabel {
color: var(--fg-secondary);
}
.arrow {
color: var(--fg-muted);
}
.toolbar {
display: flex;
align-items: center;
gap: var(--space-2);
}
.spacer {
flex: 1;
}
.count,
.direction {
color: var(--fg-muted);
}
.panes {
display: flex;
gap: var(--space-2);
flex: 1;
min-height: 0;
}
.tree {
display: flex;
flex-direction: column;
flex: 1.2;
min-width: 0;
border: 1px solid var(--border);
border-radius: var(--radius-control);
overflow: hidden;
}
.tree > * {
flex: 1;
min-height: 0;
}
.preview {
flex: 1;
min-width: 0;
}
.row {
display: inline-flex;
align-items: center;
gap: var(--space-1-5);
min-width: 0;
}
.name {
white-space: nowrap;
}
.detail {
overflow: hidden;
color: var(--fg-muted);
text-overflow: ellipsis;
white-space: nowrap;
}
.state {
width: 12px;
font-weight: 600;
text-align: center;
}
.added {
color: var(--vcs-added);
}
.removed {
color: var(--vcs-deleted);
}
.changed {
color: var(--vcs-modified);
}
.same {
color: var(--fg-muted);
}
+334
Переглянути файл
@@ -0,0 +1,334 @@
/**
* Compare Structure (DataGrip's schema comparison): pick a source and a target schema,
* see their differences — tables, columns, indexes, foreign keys — choose the ones to
* migrate and preview the SQL that makes the target match the source. Nothing runs: the
* script is copied or opened in a query console of the target.
*/
import { useEffect, useMemo, useRef, useState } from "react";
import clsx from "clsx";
import { tx } from "@/platform/i18n";
import { Button, Checkbox, Dialog, EmptyState, Icon, Select, Spinner, T, Tree, type SelectOption } from "@/ui";
import { notifications } from "@/workbench/contributions";
import { CodePreview } from "./CodePreview";
import {
diffSchemas,
differenceKeys,
migrationSql,
type DiffState,
type ItemDiff,
type TableDiff,
} from "./schemaCompare";
import {
closeDialog,
loadSchemas,
loadSources,
openConsoleWith,
schemaSnapshot,
sourceById,
targetLabel,
useDatabase,
} from "./store";
import styles from "./SchemaCompare.module.css";
interface Side {
id: string;
schema: string;
}
/** A row of the differences tree: a table, a group of its items, or an item. */
type Row =
| { kind: "table"; key: string; diff: TableDiff }
| { kind: "group"; key: string; label: string; items: ItemDiff<unknown>[]; table: TableDiff }
| { kind: "item"; key: string; diff: ItemDiff<unknown>; table: TableDiff; what: "column" | "index" | "foreignKey" };
const STATE_LABEL: Record<DiffState, string> = {
added: "Only in source",
removed: "Only in target",
changed: "Different",
same: "Identical",
};
function SidePicker({ label, side, onChange }: { label: string; side: Side; onChange: (side: Side) => void }) {
const sources = useDatabase((s) => s.sources);
const schemas = useDatabase((s) => (side.id ? s.schemas[side.id] : undefined));
useEffect(() => {
if (side.id && !useDatabase.getState().schemas[side.id]) void loadSchemas(side.id);
}, [side.id]);
const sourceOptions: SelectOption[] = sources.map((s) => ({
value: s.id ?? "",
label: s.name ?? "",
icon: "database",
}));
if (side.id && !sourceOptions.some((o) => o.value === side.id))
sourceOptions.push({ value: side.id, label: targetLabel(side.id), icon: "database" });
const names = schemas?.status === "ok" ? schemas.value : [];
const schemaOptions: SelectOption[] = names.map((n) => ({ value: n, label: n, icon: "db-schema" }));
if (side.schema && !names.includes(side.schema)) schemaOptions.unshift({ value: side.schema, label: side.schema });
return (
<div className={styles.side}>
<span className={styles.sideLabel}>
<T>{label}</T>
</span>
<Select
aria-label={tx`${tx(label)} data source`}
value={side.id || null}
placeholder="<data source>"
options={sourceOptions}
onChange={(id) => onChange({ id, schema: sourceById(id)?.driver === "sqlite" ? "main" : "" })}
/>
<Select
aria-label={tx`${tx(label)} schema`}
value={side.schema || null}
placeholder="<schema>"
options={schemaOptions}
searchable={schemaOptions.length > 10}
disabled={!side.id}
onChange={(schema) => onChange({ ...side, schema })}
/>
</div>
);
}
function StateIcon({ state }: { state: DiffState }) {
return (
<span
className={clsx(styles.state, styles[state])}
title={tx(STATE_LABEL[state])}
aria-label={tx(STATE_LABEL[state])}
>
{state === "added" ? "+" : state === "removed" ? "−" : state === "changed" ? "≠" : "="}
</span>
);
}
function itemDetail(row: Extract<Row, { kind: "item" }>): string {
const d = row.diff;
if (row.what === "column") {
const c = (x: unknown) => x as { dataType: string; nullable: boolean; default: string | null } | undefined;
const s = c(d.source);
const t = c(d.target);
const text = (x: ReturnType<typeof c>) =>
x ? `${x.dataType}${x.nullable ? "" : " not null"}${x.default ? ` default ${x.default}` : ""}` : "";
if (d.state === "changed") return `${text(t)} → ${text(s)}`;
return text(s ?? t);
}
if (row.what === "index") {
const i = (d.source ?? d.target) as { unique: boolean; columns: string[] };
return `${i.unique ? "unique " : ""}(${i.columns.join(", ")})`;
}
return "";
}
/** The direction of the migration, said in the footer. */
function migrates(source: Side, target: Side): string {
const from = `${targetLabel(source.id)}.${source.schema}`;
const to = `${targetLabel(target.id)}.${target.schema}`;
return tx`Migrates ${to} to match ${from}`;
}
function includeLabel(r: Row): string {
const name = r.kind === "group" ? tx(r.label) : r.diff.name;
return tx`Include ${name}`;
}
export function SchemaCompareDialog({ initial }: { initial: Side | null }) {
const [source, setSource] = useState<Side>(initial ?? { id: "", schema: "" });
const [target, setTarget] = useState<Side>({ id: "", schema: "" });
const [diffs, setDiffs] = useState<TableDiff[] | null>(null);
const [busy, setBusy] = useState(false);
const [error, setError] = useState<string | null>(null);
const [onlyDifferences, setOnlyDifferences] = useState(true);
const [picked, setPicked] = useState<Set<string>>(new Set());
const [expanded, setExpanded] = useState<Set<string>>(new Set());
const abort = useRef<AbortController | null>(null);
useEffect(() => {
if (!useDatabase.getState().loaded) void loadSources();
return () => abort.current?.abort();
}, []);
const ready = !!(source.id && source.schema && target.id && target.schema);
const same = source.id === target.id && source.schema === target.schema;
const targetDriver = sourceById(target.id)?.driver ?? "sqlite";
const compare = async () => {
abort.current?.abort();
const controller = (abort.current = new AbortController());
setBusy(true);
setError(null);
try {
const [s, t] = await Promise.all([
schemaSnapshot(source.id, source.schema, controller.signal),
schemaSnapshot(target.id, target.schema, controller.signal),
]);
if (controller.signal.aborted) return;
const result = diffSchemas(s, t);
setDiffs(result);
setPicked(differenceKeys(result));
// Changed tables open down to their differing items.
const open = result.filter((d) => d.state === "changed");
setExpanded(
new Set(open.flatMap((d) => [d.key, ...["Columns", "Indexes", "Foreign Keys"].map((g) => `${d.key}/${g}`)])),
);
} catch (e) {
if (!controller.signal.aborted) setError(e instanceof Error ? e.message : String(e));
} finally {
if (!controller.signal.aborted) setBusy(false);
}
};
const shown = useMemo(
() => (diffs ?? []).filter((d) => !onlyDifferences || d.state !== "same"),
[diffs, onlyDifferences],
);
const sql = useMemo(
() => (diffs ? migrationSql(targetDriver, target.schema, diffs, picked) : ""),
[diffs, picked, targetDriver, target.schema],
);
const differences = (diffs ?? []).filter((d) => d.state !== "same").length;
const children = (row: Row): Row[] | undefined => {
if (row.kind === "table") {
const d = row.diff;
const groups: Row[] = [];
const add = (label: string, items: ItemDiff<unknown>[]) => {
const visible = items.filter((i) => !onlyDifferences || i.state !== "same");
if (visible.length) groups.push({ kind: "group", key: `${d.key}/${label}`, label, items: visible, table: d });
};
add("Columns", d.columns);
add("Indexes", d.indexes);
add("Foreign Keys", d.foreignKeys);
return groups;
}
if (row.kind === "group") {
const what = row.label === "Columns" ? "column" : row.label === "Indexes" ? "index" : "foreignKey";
return row.items.map((diff) => ({ kind: "item", key: diff.key, diff, table: row.table, what }));
}
return undefined;
};
/** The keys a row's checkbox covers: a table covers its items too. */
const keysOf = (row: Row): string[] => {
if (row.kind === "item") return row.diff.state === "same" ? [] : [row.diff.key];
const d = row.kind === "table" ? row.diff : row.table;
const items = row.kind === "group" ? row.items : [...d.columns, ...d.indexes, ...d.foreignKeys];
const own = row.kind === "table" && d.state !== "same" ? [d.key] : [];
return [...own, ...items.filter((i) => i.state !== "same").map((i) => i.key)];
};
const toggle = (row: Row, on: boolean) =>
setPicked((p) => {
const next = new Set(p);
for (const k of keysOf(row)) {
if (on) next.add(k);
else next.delete(k);
}
return next;
});
const roots: Row[] = shown.map((diff) => ({ kind: "table", key: diff.key, diff }));
const copy = async () => {
await navigator.clipboard.writeText(sql);
notifications().notify({ level: "info", title: "Migration script copied", key: "db-compare" });
};
return (
<Dialog
open
onClose={closeDialog}
title="Compare Structure"
width={1040}
footerStart={<span className={styles.direction}>{ready && migrates(source, target)}</span>}
buttons={[
{ label: "Close", role: "cancel" },
{ label: "Copy", disabled: !sql, onClick: () => void copy() },
{
label: "Open in Console",
role: "default",
disabled: !sql,
onClick: () => {
closeDialog();
void openConsoleWith(target.id, sql);
},
},
]}
>
<div className={styles.body}>
<div className={styles.pickers}>
<SidePicker label="Source" side={source} onChange={setSource} />
<Icon name="arrow-right" size={14} className={styles.arrow} />
<SidePicker label="Target" side={target} onChange={setTarget} />
<Button size="small" variant="primary" disabled={!ready || same || busy} onClick={() => void compare()}>
<T>Compare</T>
</Button>
{busy && <Spinner size={14} />}
</div>
<div className={styles.toolbar}>
<Checkbox checked={onlyDifferences} onChange={setOnlyDifferences} label="Show only differences" />
<span className={styles.spacer} />
{diffs && <span className={styles.count}>{tx`${differences} of ${diffs.length} tables differ`}</span>}
</div>
<div className={styles.panes}>
<div className={styles.tree}>
{error ? (
<EmptyState title="Cannot compare">{error}</EmptyState>
) : !diffs ? (
<EmptyState
title={busy ? "Reading the schemas…" : "Pick a source and a target schema, then Compare"}
icon="diff-side-by-side"
/>
) : (
<Tree<Row>
roots={roots}
getKey={(r) => r.key}
getLabel={(r) => (r.kind === "table" ? r.diff.name : r.kind === "group" ? r.label : r.diff.name)}
getChildren={children}
isExpandable={(r) => r.kind !== "item"}
expanded={expanded}
onExpandedChange={(next) => setExpanded(next)}
aria-label={tx("Differences")}
empty={<EmptyState title="The schemas have the same structure" />}
renderNode={(r) => {
const keys = keysOf(r);
const on = keys.filter((k) => picked.has(k)).length;
const state = r.kind === "group" ? null : r.diff.state;
return (
<span className={styles.row}>
{keys.length > 0 && (
<Checkbox
checked={on === keys.length}
indeterminate={on > 0 && on < keys.length}
onChange={(v) => toggle(r, v)}
aria-label={includeLabel(r)}
/>
)}
{state && <StateIcon state={state} />}
<Icon
name={
r.kind === "table"
? "db-table"
: r.kind === "group"
? "db-folder"
: r.what === "column"
? "db-column"
: r.what === "index"
? "db-index"
: "db-foreign-key"
}
size={14}
/>
<span className={styles.name}>
{r.kind === "table" ? r.diff.name : r.kind === "group" ? tx(r.label) : r.diff.name}
</span>
{r.kind === "item" && <span className={styles.detail}>{itemDetail(r)}</span>}
</span>
);
}}
/>
)}
</div>
<CodePreview sql className={styles.preview} aria-label="Migration script" text={sql} />
</div>
</div>
</Dialog>
);
}
+37
Переглянути файл
@@ -0,0 +1,37 @@
.page {
display: flex;
flex-direction: column;
gap: var(--space-2);
color: var(--fg);
font-size: var(--fs-ui);
}
.intro,
.hint {
margin: 0;
color: var(--fg-muted);
}
.list {
display: flex;
flex-direction: column;
border: 1px solid var(--border-strong);
border-radius: var(--radius-small);
padding: var(--space-0-5) 0;
}
.head,
.row {
display: grid;
grid-template-columns: minmax(160px, 2fr) minmax(140px, 1.5fr) minmax(100px, 1fr) 24px;
align-items: center;
gap: var(--space-2);
min-height: 30px;
padding: 0 var(--space-2);
}
.head {
min-height: 24px;
color: var(--fg-muted);
border-bottom: 1px solid var(--border);
}
.project {
padding-left: var(--space-1);
font-weight: 600;
}
+144
Переглянути файл
@@ -0,0 +1,144 @@
/**
* Languages & Frameworks › SQL Resolution Scopes: which data source (and schema) SQL in a
* folder or file resolves against — completion, inspections, navigation and running
* consoles there. The project row applies wherever no folder or file row does.
*/
import { useEffect, useState } from "react";
import { call, commands, type DataSource } from "@/platform/ipc";
import { tx } from "@/platform/i18n";
import { IconButton, Input, Select, T, type SelectOption } from "@/ui";
import { useSettingsForm } from "@/workbench/contributions";
import { scopePath, validateResolutionScopes, type SqlResolutionScope } from "./resolutionScopes";
import styles from "./SqlScopesPage.module.css";
const KEY = "database.resolutionScopes";
const NONE = "";
/** An example path, the same in every language. */
const PATH_EXAMPLE = "src/main/resources/mapper";
function useDataSources(): DataSource[] | null {
const [sources, setSources] = useState<DataSource[] | null>(null);
useEffect(() => {
let stale = false;
call(commands.dbSources())
.then((list) => !stale && setSources(list))
.catch(() => !stale && setSources([]));
return () => {
stale = true;
};
}, []);
return sources;
}
export function SqlScopesPage() {
const form = useSettingsForm();
const scopes = validateResolutionScopes(form.useValue(KEY));
const sources = useDataSources();
const set = (next: SqlResolutionScope[]) => form.set(KEY, next);
const options: SelectOption[] = [
{ value: NONE, label: tx("<none>") },
...(sources ?? []).map((s) => ({ value: s.id ?? "", label: s.name ?? s.id ?? "", icon: "database" })),
];
const sourceOptions = (current: string) =>
current && !options.some((o) => o.value === current)
? [...options, { value: current, label: tx`${current} (missing)` }]
: options;
const projectIndex = scopes.findIndex((s) => !s.path);
const project = scopes[projectIndex];
const rows = scopes.map((scope, index) => ({ scope, index })).filter(({ index }) => index !== projectIndex);
const empty = (): SqlResolutionScope => ({ path: "", dataSource: NONE, schema: "" });
const patch = (index: number, p: Partial<SqlResolutionScope>) =>
set(scopes.map((s, i) => (i === index ? { ...s, ...p } : s)));
const setProject = (p: Partial<SqlResolutionScope>) =>
project ? patch(projectIndex, p) : set([{ ...empty(), ...p }, ...scopes]);
return (
<div className={styles.page}>
<p className={styles.intro}>
<T>
SQL in these folders and files resolves against the data source: completion, inspections and navigation use
its tables, and query consoles run on it unless another data source is picked in their toolbar.
</T>
</p>
<div className={styles.list} role="table" aria-label={tx("SQL Resolution Scopes")}>
<div className={styles.head} role="row">
<span role="columnheader">
<T>Path</T>
</span>
<span role="columnheader">
<T>Data Source</T>
</span>
<span role="columnheader">
<T>Schema</T>
</span>
<span />
</div>
<div className={styles.row} role="row">
<span className={styles.project} role="cell">
<T>Project</T>
</span>
<Select
value={project?.dataSource ?? NONE}
options={sourceOptions(project?.dataSource ?? NONE)}
onChange={(dataSource) => setProject({ dataSource })}
aria-label={tx("Project data source")}
/>
<Input
mono
value={project?.schema ?? ""}
placeholder={tx("Default")}
onChange={(e) => setProject({ schema: e.target.value })}
aria-label={tx("Project schema")}
/>
<span />
</div>
{rows.map(({ scope, index }) => (
<div key={index} className={styles.row} role="row">
<Input
mono
value={scope.path}
placeholder={PATH_EXAMPLE}
invalid={!scopePath(scope.path)}
onChange={(e) => patch(index, { path: e.target.value })}
aria-label={tx("Path")}
/>
<Select
value={scope.dataSource}
options={sourceOptions(scope.dataSource)}
onChange={(dataSource) => patch(index, { dataSource })}
aria-label={tx("Data source")}
/>
<Input
mono
value={scope.schema}
placeholder={tx("Default")}
onChange={(e) => patch(index, { schema: e.target.value })}
aria-label={tx("Schema")}
/>
<IconButton
icon="trash"
size="small"
title="Remove"
onClick={() => set(scopes.filter((_, i) => i !== index))}
/>
</div>
))}
</div>
<div>
<IconButton
icon="plus"
size="small"
title="Add Folder or File"
// The first row without a path is the project's: keep one ahead of the new row.
onClick={() => set([...(project ? [] : [empty()]), ...scopes, empty()])}
/>
</div>
<p className={styles.hint}>
<T>Paths are relative to the project root. The deepest folder or file that contains a file applies to it.</T>
</p>
</div>
);
}
+233 -8
Переглянути файл
@@ -39,13 +39,14 @@ import {
type Panel,
type Tooltip,
} from "@codemirror/view";
import { useEffect, useMemo, useState } from "react";
import { useEffect, useMemo, useRef, useState, type PointerEvent } from "react";
import { createRoot } from "react-dom/client";
import type { EditorDocContext } from "@/editor/api";
import { iconNode } from "@/ui/iconNode";
import { call, commands, type DbDriver, type DbSessionContext, type DbStatementOutcome } from "@/platform/ipc";
import { shortcutLabel } from "@/platform/keymap";
import { IconButton, Select } from "@/ui";
import { IconButton, Select, lazyComponent } from "@/ui";
import { useProject } from "@/platform/project";
import { activeSchema, schemaSwitchable, sourceLabel, splitTarget, targetOf } from "./model";
import { loadSavedCatalog, offerIntrospection } from "./introspection";
import { analyze, templateContexts, valuesSlot } from "./sql/analyze";
@@ -56,11 +57,14 @@ import {
type SqlCandidate,
type SqlCatalog,
} from "./sql/complete";
import { sqlSupport } from "./sqlSupport";
import { WHOLE_FILE, sqlSupport, type SqlText } from "./sqlSupport";
import { snowflakeLanguage } from "./sql/snowflakeHighlight";
import {
bindConsole,
cancelConsole,
closeInlineResults,
inEditorResults,
setInEditorResults,
consoleSchema,
consoleSource,
executeConsole,
@@ -84,6 +88,7 @@ import {
import styles from "./Database.module.css";
import { tx } from "@/platform/i18n";
import { databaseRequest, projectRequest } from "./requests";
import type { ResultTab } from "./store";
/** `templates` feature's language-data key for finer template contexts. */
const TEMPLATE_CONTEXT_KEY = "openideaTemplateContexts";
@@ -252,6 +257,213 @@ export async function explainInView(view: EditorView, path: string) {
const consolePath = Facet.define<string, string>({ combine: (v) => v[0] ?? "" });
/** An in-editor result and the statement it shows under (mapped through edits). */
interface InlineAnchor {
id: number;
from: number;
to: number;
}
/**
* Where each in-editor result's statement is now and how tall the result is, by result id:
* a console's view can be rebuilt (closed and reopened), and its results go back where they were.
*/
const anchors = new Map<number, { from: number; to: number }>();
const heights = new Map<number, number>();
const MAX_FIT_HEIGHT = 320;
const MIN_HEIGHT = 96;
/** Toolbar, notice, header row, the rows and room for the floating pager, up to `MAX_FIT_HEIGHT`. */
function fitHeight(tab: ResultTab | undefined): number {
const rows = tab?.outcome.result?.rows.length ?? 0;
return Math.max(MIN_HEIGHT, Math.min(MAX_FIT_HEIGHT, 40 + 24 + 24 + Math.max(rows, 1) * 24 + 56));
}
const setInline = StateEffect.define<InlineAnchor[]>();
/** An in-editor result was resized: its widget is redrawn so the editor measures it again. */
const resized = StateEffect.define<null>();
function anchorOf(tab: ResultTab): InlineAnchor {
return { id: tab.id, ...(anchors.get(tab.id) ?? { from: tab.outcome.statement.from, to: tab.outcome.statement.to }) };
}
const inlineField = StateField.define<readonly InlineAnchor[]>({
create: (state) => {
const path = state.facet(consolePath);
return useDatabase
.getState()
.inline.filter((t) => t.path === path)
.map(anchorOf)
.filter((a) => a.to <= state.doc.length);
},
update(value, tr) {
for (const e of tr.effects) {
if (e.is(setInline)) value = e.value;
else if (e.is(resized)) value = [...value];
}
if (!tr.docChanged) return value;
const next: InlineAnchor[] = [];
for (const a of value) {
const from = tr.changes.mapPos(a.from, 1);
const to = tr.changes.mapPos(a.to, -1);
// The statement was deleted: so is its result (the store drops it in `syncInline`).
if (to <= from) continue;
anchors.set(a.id, { from, to });
next.push({ id: a.id, from, to });
}
return next;
},
// Under the statement's last line.
provide: (f) =>
EditorView.decorations.compute([f], (state) =>
Decoration.set(
state
.field(f)
.map((a) =>
Decoration.widget({ widget: new InlineResultWidget(a.id, heightOf(a.id)), block: true, side: 1 }).range(
state.doc.lineAt(a.to).to,
),
),
true,
),
),
});
/**
* Keeps the view's in-editor results in step with the store: a run's new results show under
* their statements (replacing what those statements showed before), closed ones go away.
*/
const syncInline = ViewPlugin.define((view) => {
const path = view.state.facet(consolePath);
let destroyed = false;
const sync = () => {
if (destroyed) return;
const current = view.state.field(inlineField);
const tabs = useDatabase.getState().inline.filter((t) => t.path === path);
const ids = new Set(tabs.map((t) => t.id));
const known = new Set(current.map((a) => a.id));
const len = view.state.doc.length;
const added = tabs
.filter((t) => !known.has(t.id))
.map(anchorOf)
.filter((a) => a.to <= len);
const overlaps = (a: InlineAnchor) => added.some((b) => b.from < a.to && a.from < b.to);
const replaced = current.filter((a) => ids.has(a.id) && overlaps(a)).map((a) => a.id);
const kept = current.filter((a) => ids.has(a.id) && !replaced.includes(a.id));
for (const a of current)
if (!ids.has(a.id)) {
anchors.delete(a.id);
heights.delete(a.id);
}
if (!added.length && kept.length === current.length) return;
for (const a of added) anchors.set(a.id, { from: a.from, to: a.to });
view.dispatch({ effects: setInline.of([...kept, ...added].sort((a, b) => a.to - b.to || a.id - b.id)) });
if (replaced.length) closeInlineResults(replaced);
};
let shown = view.state.field(inlineField);
const stop = useDatabase.subscribe((s, prev) => {
if (s.inline !== prev.inline) queueMicrotask(sync);
});
queueMicrotask(sync);
return {
// Results whose statements were deleted go too.
update(u) {
const next = u.state.field(inlineField);
if (next === shown) return;
const gone = shown.filter((a) => !next.some((b) => b.id === a.id)).map((a) => a.id);
shown = next;
if (gone.length && u.docChanged) queueMicrotask(() => closeInlineResults(gone));
},
destroy: () => {
destroyed = true;
stop();
},
};
});
function heightOf(id: number): number {
return heights.get(id) ?? fitHeight(useDatabase.getState().inline.find((r) => r.id === id));
}
const InlineGrid = lazyComponent(() => import("./ResultsView").then((m) => m.Result));
function InlineResult({ id, view }: { id: number; view: EditorView }) {
const tab = useDatabase((s) => s.inline.find((r) => r.id === id));
const [height, setHeight] = useState(() => heightOf(id));
const drag = useRef<{ y: number; height: number } | null>(null);
const measured = useRef(height);
useEffect(() => {
if (measured.current === height) return;
measured.current = height;
view.dispatch({ effects: resized.of(null) });
}, [height, view]);
if (!tab) return null;
const onPointerDown = (e: PointerEvent<HTMLDivElement>) => {
e.preventDefault();
e.currentTarget.setPointerCapture(e.pointerId);
drag.current = { y: e.clientY, height };
};
const onPointerMove = (e: PointerEvent<HTMLDivElement>) => {
if (!drag.current) return;
const next = Math.max(MIN_HEIGHT, Math.round(drag.current.height + e.clientY - drag.current.y));
heights.set(id, next);
setHeight(next);
};
return (
<div className={styles.inlineResult} style={{ height }}>
<InlineGrid tab={tab} onClose={() => closeInlineResults([id])} />
<div
className={styles.inlineResize}
role="separator"
aria-orientation="horizontal"
aria-label={tx("Resize")}
onPointerDown={onPointerDown}
onPointerMove={onPointerMove}
onPointerUp={() => (drag.current = null)}
/>
</div>
);
}
const inlineRoots = new WeakMap<HTMLElement, ReturnType<typeof createRoot>>();
class InlineResultWidget extends WidgetType {
constructor(
readonly id: number,
readonly height: number,
) {
super();
}
eq(other: InlineResultWidget) {
return other.id === this.id && other.height === this.height;
}
/** A resized result keeps its DOM (and grid state); only the editor's measurement changes. */
updateDOM(dom: HTMLElement) {
return dom.dataset.result === String(this.id);
}
get estimatedHeight() {
return this.height + 12;
}
toDOM(view: EditorView) {
const dom = document.createElement("div");
dom.className = "cm-openidea-db-inline";
dom.contentEditable = "false";
dom.dataset.result = String(this.id);
const root = createRoot(dom);
inlineRoots.set(dom, root);
root.render(<InlineResult id={this.id} view={view} />);
return dom;
}
destroy(dom: HTMLElement) {
const root = inlineRoots.get(dom);
inlineRoots.delete(dom);
queueMicrotask(() => root?.unmount());
}
ignoreEvent() {
return true;
}
}
function ConsoleBar({ path, view }: { path: string; view: EditorView }) {
const sources = useDatabase((s) => s.sources);
const loaded = useDatabase((s) => s.loaded);
@@ -261,6 +473,9 @@ function ConsoleBar({ path, view }: { path: string; view: EditorView }) {
const manual = useDatabase((s) => !!bound && s.manualCommit.has(bound));
const pending = useDatabase((s) => !!bound && s.pendingTx.has(bound));
const databases = useDatabase((s) => s.databases);
const inEditor = useProject((s) => inEditorResults(s.settings));
// SQL resolution scopes in the settings can move the console to another data source.
useProject((s) => s.settings);
const boundId = bound ? splitTarget(bound).id : null;
const supportsTransactions = sourceById(boundId)?.driver !== "clickhouse";
const sqlServer = sourceById(boundId)?.driver === "sqlServer";
@@ -348,6 +563,12 @@ function ConsoleBar({ path, view }: { path: string; view: EditorView }) {
/>
<span className={styles.toolbarSeparator} />
<IconButton icon="history" title="Browse Query History" disabled={!bound} onClick={() => openHistory(path)} />
<IconButton
icon="db-in-editor-results"
title="In-Editor Results"
aria-pressed={inEditor}
onClick={() => void setInEditorResults(!inEditor)}
/>
<span className={styles.toolbarSeparator} />
<Select
aria-label="Row limit"
@@ -508,7 +729,7 @@ function docNode(text: string): Node {
return pre;
}
function applyCandidate(c: SqlCandidate, driver: DbDriver) {
function applyCandidate(c: SqlCandidate, driver: DbDriver, sql: SqlText) {
return (view: EditorView, completion: Completion, from: number, to: number) => {
// A selected template placeholder is replaced, as CodeMirror's own string completions do.
const sel = view.state.selection.main;
@@ -531,7 +752,7 @@ function applyCandidate(c: SqlCandidate, driver: DbDriver) {
}
const changes: Array<{ from: number; to?: number; insert: string }> = [{ from, to, insert: text }];
// Re-read the statement as it is now: the user may have typed on since the popup opened.
const a = analyze(view.state.doc.toString(), to, driver);
const a = analyze(sql.text(view.state), to, driver);
if (a.fromInsert !== null) {
const clause = ` ${a.lowerKeywords ? "from" : "FROM"} ${c.addFrom}`;
if (a.fromInsert <= to) changes[0]!.insert += clause;
@@ -632,8 +853,10 @@ async function loadQualified(id: string, qualifier: readonly string[]): Promise<
if (schema && !useDatabase.getState().tables[tablesKey(target, schema)]) await loadTables(target, schema);
}
function completionSource(path: string): CompletionSource {
/** SQL completion in `path`, where `sql` says the SQL is (the whole file, or a mapper's statements). */
export function completionSource(path: string, sql: SqlText = WHOLE_FILE): CompletionSource {
return async (ctx: CompletionContext): Promise<CompletionResult | null> => {
if (sql.at && !sql.at(ctx.state, ctx.pos)) return null;
const id = consoleSource(path);
const current = id ? databaseRequest(id) : projectRequest();
const source = sourceById(id);
@@ -646,7 +869,7 @@ function completionSource(path: string): CompletionSource {
// A selected template placeholder (`alias`) is about to be replaced: analyze without it.
const sel = ctx.state.selection.main;
const placeholder = !sel.empty && (ctx.pos === sel.from || ctx.pos === sel.to);
const doc = ctx.state.doc.toString();
const doc = sql.text(ctx.state);
const analysis = placeholder
? analyze(doc.slice(0, sel.from) + doc.slice(sel.to), sel.from, driver)
: analyze(doc, ctx.pos, driver);
@@ -674,7 +897,7 @@ function completionSource(path: string): CompletionSource {
type: c.kind === "keyword" ? "keyword" : c.kind,
boost: Math.max(-99, Math.min(99, c.boost)),
info: c.doc ? () => docNode(c.doc!) : undefined,
apply: applyCandidate(c, driver),
apply: applyCandidate(c, driver, sql),
})),
validFor: /^[\p{L}\p{N}_$]*$/u,
};
@@ -779,6 +1002,8 @@ export function consoleExtension(ctx: EditorDocContext): Extension {
consolePath.of(ctx.path),
runField,
runGutter,
inlineField,
syncInline,
showPanel.of(consolePanel(ctx.path)),
EditorState.languageData.of(() => [
{ openideaCompletion: completionSource(ctx.path), [TEMPLATE_CONTEXT_KEY]: templateContextsAt(ctx.path) },
+136
Переглянути файл
@@ -0,0 +1,136 @@
import { act } from "@testing-library/react";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { useProject } from "@/platform/project";
import { consoleExtension } from "./console";
import { SQL_LANGUAGE } from "./sqlLanguage";
import { executeConsole, rerunResult, useDatabase } from "./store";
const backend = vi.hoisted(() => ({ execute: vi.fn(), statements: vi.fn() }));
vi.mock("@/platform/ipc", async (importOriginal) => {
const actual = await importOriginal<typeof import("@/platform/ipc")>();
return {
...actual,
commands: { ...actual.commands, dbExecute: backend.execute, dbStatements: backend.statements },
};
});
vi.mock("@tanstack/react-virtual", () => ({
useVirtualizer: ({ count }: { count: number }) => ({
getTotalSize: () => count * 24,
getVirtualItems: () => Array.from({ length: count }, (_, index) => ({ index, start: index * 24, key: index })),
scrollToIndex: () => {},
}),
}));
const PATH = "/p/console.sql";
const initial = useDatabase.getState();
let runs = 0;
beforeEach(() => {
runs = 0;
useProject.setState({
project: { name: "p", root: "/p", trusted: true } as never,
settings: { database: { inEditorResults: true } } as never,
});
useDatabase.setState({
...initial,
loaded: true,
sources: [{ id: "pg", name: "Local", driver: "postgres", readOnly: false }],
completion: { pg: { defaultSchema: "public", tables: [], foreignKeys: [] } },
consoles: { [PATH]: "pg" },
results: [],
inline: [],
});
backend.statements.mockImplementation((_id: unknown, text: string, from: number, to: number) => {
let at = 0;
const all = text.split(";").flatMap((part) => {
const start = at + part.length - part.trimStart().length;
at += part.length + 1;
const st = part.trim();
return st ? [{ from: start, to: start + st.length, text: st }] : [];
});
const picked = from === to ? all.filter((s) => s.from <= from && from <= s.to + 1) : all;
return Promise.resolve({ status: "ok", data: picked });
});
backend.execute.mockImplementation((_r: unknown, _id: unknown, statements: Array<{ text: string }>) => {
runs++;
return Promise.resolve({
status: "ok",
data: statements.map((st) => ({
statement: st,
result: {
statement: st.text,
columns: [{ name: "v", typeName: "text" }],
rows: [[`${st.text} #${runs}`]],
affected: null,
hasMore: false,
elapsedMs: 1,
executionMs: 1,
},
error: null,
})),
});
});
});
afterEach(() => {
document.body.innerHTML = "";
});
describe("In-Editor Results", () => {
it("keeps a run's result sets out of the result tabs, and re-runs them in place", async () => {
await executeConsole(PATH, "SELECT 1; SELECT 2", 0, 18);
const st = useDatabase.getState();
expect(st.results).toEqual([]);
expect(st.inline.map((r) => r.outcome.statement.text)).toEqual(["SELECT 1", "SELECT 2"]);
const id = st.inline[0]!.id;
await rerunResult(id);
expect(useDatabase.getState().inline[0]!.outcome.result!.rows).toEqual([["SELECT 1 #2"]]);
expect(useDatabase.getState().inline[0]!.id).toBe(id);
});
it("goes to the result tabs while the setting is off", async () => {
useProject.setState({ settings: {} as never });
await executeConsole(PATH, "SELECT 1", 0, 0);
expect(useDatabase.getState().inline).toEqual([]);
expect(useDatabase.getState().results).toHaveLength(1);
});
it("shows each result under its statement, replaces it on a re-run and drops it with the statement", async () => {
const parent = document.createElement("div");
document.body.append(parent);
const doc = "SELECT 1;\nSELECT 2;\n";
const view = new EditorView({
parent,
state: EditorState.create({
doc,
extensions: consoleExtension({ language: SQL_LANGUAGE, path: PATH } as never),
}),
});
const widgets = () => [...view.dom.querySelectorAll(".cm-openidea-db-inline")];
const ids = () => useDatabase.getState().inline.map((r) => r.id);
await act(async () => void (await executeConsole(PATH, view.state.doc.toString(), 0, doc.length)));
await act(async () => {});
expect(widgets()).toHaveLength(2);
const [first, second] = ids();
// Running the first statement again replaces only its own result.
await act(async () => void (await executeConsole(PATH, view.state.doc.toString(), 0, 0)));
await act(async () => {});
expect(ids()).toHaveLength(2);
expect(ids()).toContain(second);
expect(ids()).not.toContain(first);
expect(widgets()).toHaveLength(2);
// Deleting the second statement closes its result.
await act(async () => view.dispatch({ changes: { from: 10, to: 19 } }));
await act(async () => {});
expect(ids()).not.toContain(second);
expect(widgets()).toHaveLength(1);
view.destroy();
});
});
+23
Переглянути файл
@@ -39,6 +39,8 @@ import {
RESULTS_VIEW,
consoleSource,
consoleTints,
inEditorResults,
setInEditorResults,
loadSources,
connect,
loadSchemas,
@@ -79,6 +81,8 @@ function tableTarget(arg: unknown): TableCommandTarget {
return { rows: activeCellGrid()?.selectedRows() ?? [], editor: null };
}
export { activateSettingsPages } from "./settingsPages";
export function activate(): () => void {
const disposers = [
onIdeEvent("dbSourcesChanged", () => {
@@ -120,6 +124,14 @@ export function activate(): () => void {
() => import("./console").then((m) => m.consoleExtension),
),
}),
registerEditorContribution({
id: "database.mybatis",
order: 58,
extensions: lazyEditorExtension(
(ctx) => /\.xml$/i.test(ctx.path) && !ctx.virtual,
() => import("./mybatis").then((m) => m.mapperExtension),
),
}),
// A reopened project starts with a fresh backend: forget the old one's state.
useProject.subscribe((s, prev) => {
if (s.project?.root === prev.project?.root) return;
@@ -135,6 +147,7 @@ export function activate(): () => void {
objects: {},
completion: {},
results: [],
inline: [],
output: [],
activeResult: null,
selectedSource: null,
@@ -262,6 +275,16 @@ export function activate(): () => void {
await (await import("./console")).executeInView(e.view, e.ctx.path);
},
},
{
id: "db.toggleInEditorResults",
title: "In-Editor Results",
description: "Show query results in the editor, under the statements that produced them",
category: "Tools",
icon: "db-in-editor-results",
keywords: ["inline", "results", "console", "grid"],
toggled: () => inEditorResults(),
run: () => setInEditorResults(!inEditorResults()),
},
{
id: "db.executeScript",
title: "Execute SQL Script",
+112
Переглянути файл
@@ -0,0 +1,112 @@
import { CompletionContext, type CompletionResult, type CompletionSource } from "@codemirror/autocomplete";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { CONTRIBUTED_HOVER, type ContributedHover } from "@/editor/api";
import { useProject } from "@/platform/project";
import { mapperExtension } from "./mybatis";
import { useDatabase } from "./store";
const published = vi.hoisted(() => new Map<string, Array<{ message: string }>>());
vi.mock("@/editor/lsp/diagnostics", () => ({
setFileDiagnostics: (path: string, _source: string, items: Array<{ message: string }>) => published.set(path, items),
}));
const PATH = "/p/src/main/resources/mapper/UserMapper.xml";
const DOC = `<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.UserMapper">
<select id="find">
select id, nam from users where id = #{id}
</select>
<select id="other">select * from orders</select>
</mapper>
`;
let view: EditorView | null = null;
beforeEach(() => {
vi.useFakeTimers();
published.clear();
useProject.setState({
project: { name: "p", root: "/p", trusted: true } as never,
settings: {
database: { resolutionScopes: [{ path: "src/main/resources/mapper", dataSource: "pg", schema: "" }] },
} as never,
});
const column = (name: string) => ({
name,
dataType: "text",
nullable: true,
primaryKey: name === "id",
hasDefault: false,
});
useDatabase.setState({
loaded: true,
sources: [
{ id: "pg", name: "Local", driver: "postgres" },
{ id: "other", name: "Other", driver: "postgres" },
],
consoles: {},
consoleSchemas: {},
completion: {
pg: {
defaultSchema: "public",
tables: [{ schema: "public", name: "users", kind: "table", columns: [column("id"), column("name")] }],
foreignKeys: [],
},
},
});
});
afterEach(() => {
view?.destroy();
view = null;
vi.useRealTimers();
});
function open(doc: string) {
view = new EditorView({
parent: document.body,
state: EditorState.create({ doc, extensions: mapperExtension({ path: PATH, language: "xml" } as never) }),
});
return view;
}
function completionAt(state: EditorState, pos: number): Promise<CompletionResult | null> {
const sources = state.languageDataAt<CompletionSource>("openideaCompletion", pos);
return Promise.resolve(sources[0]!(new CompletionContext(state, pos, true)));
}
describe("SQL in MyBatis mappers", () => {
it("reports unresolved names of the statements against the scope's data source", () => {
open(DOC);
vi.advanceTimersByTime(1000);
const messages = (published.get(PATH) ?? []).map((d) => d.message);
expect(messages.some((m) => /nam\b/.test(m))).toBe(true);
expect(messages.some((m) => /orders/.test(m))).toBe(true);
expect(messages.some((m) => /users|\bid\b/.test(m))).toBe(false);
});
it("documents tables in the statements and nothing in the XML around them", () => {
const v = open(DOC);
const hover = v.state.languageDataAt<ContributedHover>(CONTRIBUTED_HOVER, 0)[0]!;
expect(hover(v.state, DOC.indexOf("users") + 2)?.markdown).toMatch(/users/);
expect(hover(v.state, DOC.indexOf("namespace") + 2)).toBeNull();
});
it("completes columns inside a statement only", async () => {
const doc = DOC.replace("select id, nam from users", "select n from users");
const v = open(doc);
const result = await completionAt(v.state, doc.indexOf("select n") + "select n".length);
expect(result?.options.map((o) => o.label)).toContain("name");
expect(await completionAt(v.state, doc.indexOf("namespace") + 4)).toBeNull();
});
it("leaves other XML files alone", () => {
const v = open("<beans><select>not sql</select></beans>");
vi.advanceTimersByTime(1000);
expect(published.get(PATH) ?? []).toEqual([]);
expect(v.dom.querySelectorAll("[class*=ͼ]").length).toBe(0);
});
});
+123
Переглянути файл
@@ -0,0 +1,123 @@
/**
* SQL in MyBatis mapper XML: the statements of `<select>`, `<insert>`, `<update>`, `<delete>`
* and `<sql>` are highlighted as SQL and get the SQL file's tools — completion, inspections,
* Go to Declaration and Quick Documentation — against the file's data source (its SQL
* resolution scope, or the project's only data source). See `sql/mapper` for what is SQL.
*/
import { MSSQL, MySQL, PLSQL, PostgreSQL, SQLite, StandardSQL, type SQLDialect } from "@codemirror/lang-sql";
import { highlightingFor } from "@codemirror/language";
import { EditorState, RangeSetBuilder, StateEffect, type Extension, type Text } from "@codemirror/state";
import { Decoration, ViewPlugin, type DecorationSet, type EditorView, type ViewUpdate } from "@codemirror/view";
import { highlightTree } from "@lezer/highlight";
import type { EditorDocContext } from "@/editor/api";
import type { DbDriver } from "@/platform/ipc";
import { completionSource } from "./console";
import { inMapperSql, isMapper, mapperSql, type MapperSql } from "./sql/mapper";
import { sqlSupport, type SqlText } from "./sqlSupport";
import { consoleSource, sourceById, useDatabase } from "./store";
const cache = new WeakMap<Text, MapperSql | null>();
/** The file's data source (and so its dialect) changed: colour the statements again. */
const recolour = StateEffect.define<null>();
/** The SQL of the mapper in `doc` (null when it is no mapper), computed once per document version. */
function mapperOf(doc: Text): MapperSql | null {
let sql = cache.get(doc);
if (sql === undefined) {
const text = doc.toString();
sql = isMapper(text) ? mapperSql(text) : null;
cache.set(doc, sql);
}
return sql;
}
const MAPPER_SQL: SqlText = {
text: (state) => mapperOf(state.doc)?.text ?? " ".repeat(state.doc.length),
at: (state, pos) => {
const sql = mapperOf(state.doc);
return !!sql && inMapperSql(sql, pos);
},
};
function dialectOf(driver: DbDriver): SQLDialect {
switch (driver) {
case "postgres":
return PostgreSQL;
case "mysql":
return MySQL;
case "sqlite":
return SQLite;
case "sqlServer":
return MSSQL;
case "oracle":
return PLSQL;
default:
return StandardSQL;
}
}
/** Syntax colours of the statements, in the bound data source's dialect, over the XML colours. */
function sqlColours(path: string): Extension {
const build = (view: EditorView): DecorationSet => {
const sql = mapperOf(view.state.doc);
if (!sql?.segments.length) return Decoration.none;
const driver = sourceById(consoleSource(path))?.driver ?? "sqlite";
const tree = dialectOf(driver).language.parser.parse(sql.text);
const builder = new RangeSetBuilder<Decoration>();
const marks = new Map<string, Decoration>();
const style = { style: (tags: Parameters<typeof highlightingFor>[1]) => highlightingFor(view.state, tags) };
let segment = 0;
for (const { from, to } of view.visibleRanges)
highlightTree(
tree,
style,
(a, b, cls) => {
// Only the file's own SQL text: the words standing in for tags are not shown.
while (segment < sql.segments.length && sql.segments[segment]!.to <= a) segment++;
for (let i = segment; i < sql.segments.length && sql.segments[i]!.from < b; i++) {
const s = sql.segments[i]!;
const f = Math.max(a, s.from);
const t = Math.min(b, s.to);
if (f >= t) continue;
let mark = marks.get(cls);
if (!mark) marks.set(cls, (mark = Decoration.mark({ class: cls })));
builder.add(f, t, mark);
}
},
from,
to,
);
return builder.finish();
};
return ViewPlugin.fromClass(
class {
decorations: DecorationSet;
private stop: () => void;
constructor(readonly view: EditorView) {
this.decorations = build(view);
// Another data source may mean another dialect.
this.stop = useDatabase.subscribe((s, prev) => {
if (s.sources !== prev.sources || s.consoles !== prev.consoles)
queueMicrotask(() => view.dispatch({ effects: recolour.of(null) }));
});
}
update(u: ViewUpdate) {
if (u.docChanged || u.viewportChanged || u.transactions.some((tr) => tr.effects.some((e) => e.is(recolour))))
this.decorations = build(u.view);
}
destroy() {
this.stop();
}
},
{ decorations: (v) => v.decorations },
);
}
/** The SQL support of MyBatis mapper `ctx.path` (inert in other XML files). */
export function mapperExtension(ctx: EditorDocContext): Extension {
return [
sqlColours(ctx.path),
EditorState.languageData.of(() => [{ openideaCompletion: completionSource(ctx.path, MAPPER_SQL) }]),
sqlSupport(ctx.path, MAPPER_SQL),
];
}
+54
Переглянути файл
@@ -0,0 +1,54 @@
import { beforeEach, describe, expect, it } from "vitest";
import { useProject } from "@/platform/project";
import { resolutionScopeOf, validateResolutionScopes } from "./resolutionScopes";
import { bindConsole, consoleSchema, consoleSource, useDatabase } from "./store";
const scopes = validateResolutionScopes([
{ path: "", dataSource: "main", schema: "" },
{ path: "./src/main/resources/mapper/", dataSource: "orders", schema: "sales" },
{ path: "src/main/resources/mapper/legacy/Old.xml", dataSource: "legacy", schema: "" },
{ path: "src/gone", dataSource: "removed", schema: "" },
]);
describe("SQL resolution scopes", () => {
it("normalises paths and picks the deepest folder or file covering a file, else the project row", () => {
expect(scopes[1]!.path).toBe("src/main/resources/mapper");
const at = (rel: string) => resolutionScopeOf(`/p/${rel}`, "/p", scopes)?.dataSource;
expect(at("src/main/resources/mapper/UserMapper.xml")).toBe("orders");
expect(at("src/main/resources/mapper/legacy/Old.xml")).toBe("legacy");
expect(at("src/main/resources/mapper/legacy/New.xml")).toBe("orders");
// A sibling folder whose name starts the same is not inside.
expect(at("src/main/resources/mapperx/A.xml")).toBe("main");
expect(resolutionScopeOf("/elsewhere/a.sql", "/p", scopes)).toBeNull();
});
it("skips rows whose data source no longer exists", () => {
const known = (id: string) => id !== "removed";
expect(resolutionScopeOf("/p/src/gone/a.sql", "/p", scopes, known)?.dataSource).toBe("main");
});
});
describe("the data source a SQL file resolves against", () => {
beforeEach(() => {
useProject.setState({
project: { name: "p", root: "/p", trusted: true } as never,
settings: { database: { resolutionScopes: scopes } } as never,
});
useDatabase.setState({
sources: ["main", "orders", "legacy"].map((id) => ({ id, name: id, driver: "postgres" as const })),
consoles: {},
consoleSchemas: {},
completion: { orders: { defaultSchema: "public", tables: [], foreignKeys: [] } },
});
});
it("is the one picked in its toolbar, else its scope's (with the scope's schema)", () => {
const file = "/p/src/main/resources/mapper/UserMapper.xml";
expect(consoleSource(file)).toBe("orders");
expect(consoleSchema(file)).toBe("sales");
bindConsole(file, "legacy");
expect(consoleSource(file)).toBe("legacy");
bindConsole(file, null);
expect(consoleSource("/p/scratch.sql")).toBe("main");
});
});
+61
Переглянути файл
@@ -0,0 +1,61 @@
/**
* Languages & Frameworks › SQL Resolution Scopes: the data source (and schema) SQL in a
* file or folder resolves against. The most specific path wins; an empty path is the
* whole project.
*/
export interface SqlResolutionScope {
/** Project-relative file or folder, `/`-separated; empty for the whole project. */
path: string;
dataSource: string;
schema: string;
}
const str = (v: unknown) => (typeof v === "string" ? v : "");
/** Normalises a project-relative path: `/`-separated, without `./` or surrounding slashes. */
export function scopePath(path: string): string {
return path
.trim()
.replace(/\\/g, "/")
.replace(/^(\.\/)+/, "")
.replace(/^\/+|\/+$/g, "");
}
export function validateResolutionScopes(raw: unknown): SqlResolutionScope[] {
if (!Array.isArray(raw)) return [];
return raw.flatMap((r) => {
if (!r || typeof r !== "object") return [];
const o = r as Record<string, unknown>;
return [{ path: scopePath(str(o.path)), dataSource: str(o.dataSource), schema: str(o.schema).trim() }];
});
}
/** The scopes in raw settings (`database.resolutionScopes`). */
export function resolutionScopesOf(settings: unknown): SqlResolutionScope[] {
const database = (settings as { database?: { resolutionScopes?: unknown } } | null)?.database;
return validateResolutionScopes(database?.resolutionScopes);
}
/**
* The scope of `file` (absolute, under project `root`) among `scopes` whose data source
* `known` accepts: the deepest folder or the file itself, else the project's row.
*/
export function resolutionScopeOf(
file: string,
root: string,
scopes: readonly SqlResolutionScope[],
known: (dataSource: string) => boolean = () => true,
): SqlResolutionScope | null {
const base = root.replace(/\\/g, "/").replace(/\/+$/, "");
const normalized = file.replace(/\\/g, "/");
if (!base || !normalized.startsWith(`${base}/`)) return null;
const rel = normalized.slice(base.length + 1);
let best: SqlResolutionScope | null = null;
for (const scope of scopes) {
if (!scope.dataSource || !known(scope.dataSource)) continue;
const p = scope.path;
const covers = !p || rel === p || rel.startsWith(`${p}/`);
if (covers && (!best || p.length > best.path.length)) best = scope;
}
return best;
}
+90
Переглянути файл
@@ -0,0 +1,90 @@
import { describe, expect, it } from "vitest";
import type { DbColumnInfo } from "@/platform/ipc";
import { diffSchemas, differenceKeys, migrationSql, type TableSnapshot } from "./schemaCompare";
const col = (name: string, dataType: string, extra: Partial<DbColumnInfo> = {}): DbColumnInfo => ({
name,
dataType,
nullable: true,
default: null,
primaryKey: false,
...extra,
});
const users = (columns: DbColumnInfo[], indexes: TableSnapshot["indexes"] = []): TableSnapshot => ({
name: "users",
kind: "table",
columns,
indexes,
foreignKeys: [],
});
const SOURCE: TableSnapshot[] = [
users(
[
col("id", "int", { nullable: false, primaryKey: true }),
col("email", "varchar(255)", { nullable: false }),
col("age", "int", { default: "0" }),
],
[
{ name: "PRIMARY", unique: true, columns: ["id"] },
{ name: "users_email", unique: true, columns: ["email"] },
],
),
{
name: "orders",
kind: "table",
columns: [col("id", "int", { nullable: false, primaryKey: true }), col("user_id", "int")],
indexes: [
{ name: "PRIMARY", unique: true, columns: ["id"] },
{ name: "orders_user", unique: false, columns: ["user_id"] },
],
foreignKeys: [
{ schema: "app", table: "orders", columns: ["user_id"], refSchema: "app", refTable: "users", refColumns: ["id"] },
],
},
];
const TARGET: TableSnapshot[] = [
users(
[col("ID", "INT", { nullable: false, primaryKey: true }), col("email", "varchar(100)"), col("nickname", "text")],
[{ name: "PRIMARY", unique: true, columns: ["id"] }],
),
{ name: "legacy", kind: "table", columns: [col("x", "int")], indexes: [], foreignKeys: [] },
];
describe("Compare Structure", () => {
const diffs = diffSchemas(SOURCE, TARGET);
it("lists added, removed and changed tables with their column and index differences", () => {
expect(diffs.map((d) => `${d.name}:${d.state}`)).toEqual(["legacy:removed", "orders:added", "users:changed"]);
const u = diffs.find((d) => d.name === "users")!;
expect(u.columns.map((c) => `${c.name}:${c.state}:${c.changes.join("+")}`)).toEqual([
"id:same:",
"email:changed:type+nullable",
"age:added:",
"nickname:removed:",
]);
expect(u.indexes.map((i) => `${i.name}:${i.state}`)).toEqual(["PRIMARY:same", "users_email:added"]);
});
it("writes the migration of the selected differences for the target's dialect", () => {
const all = migrationSql("mysql", "app", diffs, differenceKeys(diffs));
expect(all).toBe(
[
"drop table app.legacy;",
"create table app.orders\n(\n id int not null,\n user_id int,\n primary key (id)\n);",
"alter table app.users change column email email varchar(255) not null;",
"alter table app.users add column age int default 0;",
"alter table app.users drop column nickname;",
"create index orders_user on app.orders (user_id);",
"alter table app.orders add foreign key (user_id) references app.users (id);",
"create unique index users_email on app.users (email);",
"",
].join("\n"),
);
// Only what is picked; identical items never produce SQL.
const some = migrationSql("postgres", "public", diffs, new Set(["c:users.age", "c:users.id", "t:legacy"]));
expect(some).toBe("drop table public.legacy;\nalter table public.users add column age int default 0;\n");
});
});
+234
Переглянути файл
@@ -0,0 +1,234 @@
/**
* Compare Structure (DataGrip's schema comparison): the differences between a source and a
* target schema — tables, columns, indexes and foreign keys — and the migration SQL that
* makes the chosen parts of the target match the source. Pure functions; nothing is run.
*/
import type { DbColumnInfo, DbDriver, DbForeignKey, DbIndexInfo, DbTableKind } from "@/platform/ipc";
import { alterTableSql, createTableSql, draftOf, ident, qualifiedName, type ColumnDraft } from "./objects";
export interface TableSnapshot {
name: string;
kind: DbTableKind;
columns: DbColumnInfo[];
indexes: DbIndexInfo[];
foreignKeys: DbForeignKey[];
}
/** `added`: only in the source (the migration creates it); `removed`: only in the target (it drops it). */
export type DiffState = "added" | "removed" | "changed" | "same";
export interface ItemDiff<T> {
/** Selection key, unique in the comparison. */
key: string;
name: string;
state: DiffState;
source?: T;
target?: T;
/** What differs, for a changed item: `type`, `nullable`, `default`, `primary key`, `unique`, `columns`, `references`. */
changes: string[];
}
export interface TableDiff extends ItemDiff<TableSnapshot> {
columns: ItemDiff<DbColumnInfo>[];
indexes: ItemDiff<DbIndexInfo>[];
foreignKeys: ItemDiff<DbForeignKey>[];
}
const norm = (s: string | null | undefined) => (s ?? "").trim().replace(/\s+/g, " ").toLowerCase();
/** Pairs items by name: exact first, then ignoring case. */
function pair<T>(
source: readonly T[],
target: readonly T[],
name: (t: T) => string,
): Array<[T | undefined, T | undefined]> {
const left = new Set(target);
const out: Array<[T | undefined, T | undefined]> = [];
for (const s of source) {
const n = name(s);
let t = [...left].find((x) => name(x) === n);
t ??= [...left].find((x) => name(x).toLowerCase() === n.toLowerCase());
if (t) left.delete(t);
out.push([s, t]);
}
for (const t of target) if (left.has(t)) out.push([undefined, t]);
return out;
}
function stateOf(source: unknown, target: unknown, changes: string[]): DiffState {
if (!target) return "added";
if (!source) return "removed";
return changes.length ? "changed" : "same";
}
function columnChanges(s: DbColumnInfo, t: DbColumnInfo): string[] {
const out: string[] = [];
if (norm(s.dataType) !== norm(t.dataType)) out.push("type");
if (s.nullable !== t.nullable) out.push("nullable");
if (norm(s.default) !== norm(t.default)) out.push("default");
if (s.primaryKey !== t.primaryKey) out.push("primary key");
return out;
}
const fkName = (k: DbForeignKey) => `(${k.columns.join(", ")}) → ${k.refTable}(${k.refColumns.join(", ")})`;
export function diffSchemas(source: readonly TableSnapshot[], target: readonly TableSnapshot[]): TableDiff[] {
return pair(source, target, (t) => t.name)
.map(([s, t]): TableDiff => {
const name = (s ?? t)!.name;
const columns = pair(s?.columns ?? [], t?.columns ?? [], (c) => c.name).map(([a, b]) => {
const changes = a && b ? columnChanges(a, b) : [];
return {
key: `c:${name}.${(a ?? b)!.name}`,
name: (a ?? b)!.name,
state: stateOf(a, b, changes),
source: a,
target: b,
changes,
};
});
const indexes = pair(s?.indexes ?? [], t?.indexes ?? [], (i) => i.name).map(([a, b]) => {
const changes: string[] = [];
if (a && b) {
if (a.unique !== b.unique) changes.push("unique");
if (norm(a.columns.join(",")) !== norm(b.columns.join(","))) changes.push("columns");
}
return {
key: `i:${name}.${(a ?? b)!.name}`,
name: (a ?? b)!.name,
state: stateOf(a, b, changes),
source: a,
target: b,
changes,
};
});
// Foreign keys have no comparable name across databases: they pair by what they link.
const foreignKeys = pair(s?.foreignKeys ?? [], t?.foreignKeys ?? [], (k) => norm(fkName(k))).map(([a, b]) => ({
key: `f:${name}.${fkName((a ?? b)!)}`,
name: fkName((a ?? b)!),
state: stateOf(a, b, []),
source: a,
target: b,
changes: [],
}));
const changes: string[] = [];
if (s && t && [...columns, ...indexes, ...foreignKeys].some((d) => d.state !== "same")) changes.push("content");
return {
key: `t:${name}`,
name,
state: stateOf(s, t, changes),
source: s,
target: t,
changes,
columns,
indexes,
foreignKeys,
};
})
.sort((a, b) => a.name.localeCompare(b.name));
}
/** Every key of a difference (not of identical items): the default selection. */
export function differenceKeys(diffs: readonly TableDiff[]): Set<string> {
const keys = new Set<string>();
for (const t of diffs) {
if (t.state === "same") continue;
keys.add(t.key);
for (const d of [...t.columns, ...t.indexes, ...t.foreignKeys]) if (d.state !== "same") keys.add(d.key);
}
return keys;
}
function createIndexSql(driver: DbDriver, schema: string, table: string, i: DbIndexInfo): string {
const cols = i.columns.map((c) => ident(driver, c)).join(", ");
return `create ${i.unique ? "unique " : ""}index ${ident(driver, i.name)} on ${qualifiedName(driver, schema, table)} (${cols});`;
}
function dropIndexSql(driver: DbDriver, schema: string, table: string, i: DbIndexInfo): string {
if (driver === "mysql" || driver === "sqlServer")
return `drop index ${ident(driver, i.name)} on ${qualifiedName(driver, schema, table)};`;
return `drop index ${qualifiedName(driver, schema, i.name)};`;
}
function addForeignKeySql(driver: DbDriver, schema: string, table: string, k: DbForeignKey): string {
const cols = (names: string[]) => names.map((c) => ident(driver, c)).join(", ");
return `alter table ${qualifiedName(driver, schema, table)} add foreign key (${cols(k.columns)}) references ${qualifiedName(driver, schema, k.refTable)} (${cols(k.refColumns)});`;
}
/**
* The statements making the selected differences of the target (`schema` on `driver`)
* match the source: drops of foreign keys and indexes first, then tables and columns,
* then new indexes and foreign keys. A dropped foreign key has no portable name: it is
* left as a comment to write by hand.
*/
export function migrationSql(
driver: DbDriver,
schema: string,
diffs: readonly TableDiff[],
selected: ReadonlySet<string>,
): string {
const first: string[] = [];
const tables: string[] = [];
const last: string[] = [];
for (const t of diffs) {
const pick = (d: ItemDiff<unknown>) => selected.has(d.key) && d.state !== "same";
if (t.state === "added") {
if (!selected.has(t.key) || !t.source) continue;
tables.push(
createTableSql(
driver,
schema,
t.name,
t.source.columns.map((c, i) => ({ ...draftOf(c, i), original: null })),
).trimEnd(),
);
// The primary key's own index comes with the table.
const key = t.source.columns.filter((c) => c.primaryKey).map((c) => norm(c.name));
const isKey = (i: DbIndexInfo) =>
i.unique && i.columns.length === key.length && i.columns.every((c) => key.includes(norm(c)));
for (const i of t.source.indexes) if (!isKey(i)) last.push(createIndexSql(driver, schema, t.name, i));
for (const k of t.source.foreignKeys) last.push(addForeignKeySql(driver, schema, t.name, k));
continue;
}
if (t.state === "removed") {
if (selected.has(t.key)) tables.push(`drop table ${qualifiedName(driver, schema, t.name)};`);
continue;
}
for (const k of t.foreignKeys)
if (pick(k) && k.state === "removed")
first.push(
`-- drop the foreign key ${k.name} of ${qualifiedName(driver, schema, t.name)} (constraint name differs per database)`,
);
for (const i of t.indexes)
if (pick(i) && (i.state === "removed" || i.state === "changed"))
first.push(dropIndexSql(driver, schema, t.name, i.target!));
const drafts: ColumnDraft[] = [];
t.columns.forEach((c, n) => {
if (!pick(c)) return;
if (c.state === "added") drafts.push({ ...draftOf(c.source!, n), original: null });
else if (c.state === "removed") drafts.push({ ...draftOf(c.target!, n), dropped: true });
else {
const s = c.source!;
drafts.push({ ...draftOf(c.target!, n), dataType: s.dataType, notNull: !s.nullable, default: s.default ?? "" });
}
});
if (drafts.length) tables.push(...alterTableSql(driver, schema, t.name, t.name, drafts));
// SQLite only adds and drops columns: a changed one is rebuilt by hand.
if (driver === "sqlite")
for (const c of t.columns)
if (pick(c) && c.state === "changed")
tables.push(
`-- SQLite cannot alter ${qualifiedName(driver, schema, t.name)}.${ident(driver, c.name)} (${c.changes.join(", ")}): rebuild the table`,
);
for (const c of t.columns)
if (pick(c) && c.changes.includes("primary key"))
last.push(`-- the primary key of ${qualifiedName(driver, schema, t.name)} changes at ${ident(driver, c.name)}`);
for (const i of t.indexes)
if (pick(i) && (i.state === "added" || i.state === "changed"))
last.push(createIndexSql(driver, schema, t.name, i.source!));
for (const k of t.foreignKeys)
if (pick(k) && k.state === "added") last.push(addForeignKeySql(driver, schema, t.name, k.source!));
}
const all = [...first, ...tables, ...last];
return all.length ? `${all.join("\n")}\n` : "";
}
+16
Переглянути файл
@@ -0,0 +1,16 @@
import { lazyComponent } from "@/ui";
import { registerSettingsPage } from "@/workbench/contributions";
/** Settings › Languages & Frameworks › SQL Resolution Scopes (also used by the Settings window). */
export function activateSettingsPages(): () => void {
return registerSettingsPage({
id: "languages.sqlResolutionScopes",
title: "SQL Resolution Scopes",
group: "Languages & Frameworks",
order: 404.5,
projectScope: true,
defaultScope: "project",
keywords: ["sql", "data source", "database", "schema", "mybatis", "mapper", "resolve", "dialect"],
component: lazyComponent(() => import("./SqlScopesPage").then((m) => m.SqlScopesPage)),
});
}
+55
Переглянути файл
@@ -0,0 +1,55 @@
import { describe, expect, it } from "vitest";
import { inMapperSql, isMapper, mapperSql } from "./mapper";
const MAPPER = `<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.UserMapper">
<resultMap id="user" type="User"><id column="id" property="id"/></resultMap>
<select id="find" resultMap="user">
select id, name from users
<where>
<if test="name != null">and name = #{name}</if>
<if test="ids != null">and id in
<foreach collection="ids" item="i" open="(" separator="," close=")">#{i}</foreach>
</if>
and age &gt; 18
</where>
</select>
<insert id="add">
<selectKey keyProperty="id" resultType="int">select last_insert_id()</selectKey>
insert into users (name) values (#{name})
</insert>
<!-- <select id="old">select * from old</select> -->
<update id="rename"><![CDATA[update users set name = #{name} where age < 3]]></update>
<update id="touch">update users <set><if test="a">name = #{a},</if></set> where id = #{id}</update>
</mapper>`;
describe("MyBatis mapper SQL", () => {
it("recognises mapper files", () => {
expect(isMapper(MAPPER)).toBe(true);
expect(isMapper("<beans><bean id='a'/></beans>")).toBe(false);
});
it("keeps the statements' SQL at its offsets and blanks the rest", () => {
const { text } = mapperSql(MAPPER);
expect(text).toHaveLength(MAPPER.length);
expect(text.split("\n")).toHaveLength(MAPPER.split("\n").length);
const sql = text.replace(/\s+/g, " ").trim();
expect(sql).toBe(
"select id, name from users where name = ? and id in ( ? ) and age > 18 ; " +
"insert into users (name) values (? ) ; update users set name = ? where age < 3 ; " +
"update users set name = ? where id = ? ;",
);
const at = MAPPER.indexOf("users");
expect(text.slice(at, at + 5)).toBe("users");
});
it("knows which offsets are SQL", () => {
const sql = mapperSql(MAPPER);
expect(inMapperSql(sql, MAPPER.indexOf("from users") + 2)).toBe(true);
expect(inMapperSql(sql, MAPPER.indexOf("resultMap="))).toBe(false);
expect(inMapperSql(sql, MAPPER.indexOf('test="name'))).toBe(false);
expect(inMapperSql(sql, MAPPER.indexOf("last_insert_id"))).toBe(false);
expect(inMapperSql(sql, MAPPER.indexOf("from old"))).toBe(false);
});
});
+154
Переглянути файл
@@ -0,0 +1,154 @@
/**
* The SQL of a MyBatis mapper XML file, as one text the SQL tools read: everything but the
* SQL of `<select>` / `<insert>` / `<update>` / `<delete>` / `<sql>` is blanked out with
* spaces (line breaks kept), so offsets are the file's own. Parameters (`#{id}`, `${col}`)
* read as `?`, entities as their character, dynamic tags as nothing — except `<where>`,
* `<set>`, `<trim prefix>` and `<foreach open / close>`, which read as what they add — and
* each statement ends with a `;`.
*/
const STATEMENTS = new Set(["select", "insert", "update", "delete", "sql"]);
/** Their content is not part of the statement's SQL. */
const SKIPPED = new Set(["selectKey"]);
const ENTITIES: Record<string, string> = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'" };
export interface MapperSql {
/** The file's text with only SQL left (same length). */
text: string;
/** The SQL text taken from the file, as ranges of offsets: the positions the SQL tools apply to. */
segments: Array<{ from: number; to: number }>;
}
/** Whether `text` is a MyBatis (or iBatis) mapper. */
export function isMapper(text: string): boolean {
const head = text.slice(0, 4000);
return /<mapper[\s>]/.test(head) && /mybatis|ibatis|<mapper[^>]*\snamespace\s*=/i.test(head);
}
const TAG = /<!--[\s\S]*?(?:-->|$)|<!\[CDATA\[|\]\]>|<(\/?)([A-Za-z_][\w.:-]*)((?:[^>"']|"[^"]*"|'[^']*')*?)(\/?)>/g;
function attr(attrs: string, name: string): string | null {
const m = new RegExp(`(?:^|\\s)${name}\\s*=\\s*("([^"]*)"|'([^']*)')`).exec(attrs);
return m ? (m[2] ?? m[3] ?? "") : null;
}
export function mapperSql(doc: string): MapperSql {
const out = doc.replace(/[^\n]/g, " ").split("");
const segments: MapperSql["segments"] = [];
/** Writes `what` at `at`, as far as `room` characters allow. */
const put = (at: number, what: string, room: number) => {
if (what.length > room) return;
for (let i = 0; i < what.length; i++) out[at + i] = what[i]!;
};
const copy = (from: number, to: number) => {
if (to <= from) return;
let at = from;
const text = doc.slice(from, to);
// Parameters and entities inside the SQL text.
const special = /#\{[^}]*\}?|\$\{[^}]*\}?|&(lt|gt|amp|quot|apos);/g;
for (let m = special.exec(text); m; m = special.exec(text)) {
const start = from + m.index;
for (let i = at; i < start; i++) out[i] = doc[i]!;
if (m[1]) put(start, ENTITIES[m[1]]!, m[0].length);
else put(start, "?", m[0].length);
at = start + m[0].length;
}
for (let i = at; i < to; i++) out[i] = doc[i]!;
const last = segments.at(-1);
if (last && last.to === from) last.to = to;
else segments.push({ from, to });
};
/** Inside a statement: its depth of nested tags, the `close` text of open `<foreach>` / `<trim>`. */
let statement: { name: string; depth: number } | null = null;
const closes: Array<{ text: string | null; trailingComma: boolean }> = [];
/** Where `<where>` / `<trim prefixOverrides>` drop a leading AND / OR, `<set>` a trailing comma. */
const leading: number[] = [];
const trailing: number[] = [];
let skipping = 0;
let textFrom = 0;
TAG.lastIndex = 0;
for (let m = TAG.exec(doc); m; m = TAG.exec(doc)) {
const at = m.index;
const end = at + m[0].length;
if (statement && !skipping) copy(textFrom, at);
textFrom = end;
const [whole, closing, name, attrs = "", selfClosing] = m;
// CDATA content is SQL text as written, markup characters included.
if (whole === "<![CDATA[") {
const close = doc.indexOf("]]>", end);
const stop = close < 0 ? doc.length : close;
if (statement && !skipping) copy(end, stop);
textFrom = TAG.lastIndex = Math.min(doc.length, stop + 3);
continue;
}
// Comments (and a stray `]]>`) are blank.
if (!name) continue;
if (!statement) {
if (!closing && !selfClosing && STATEMENTS.has(name)) statement = { name, depth: 0 };
continue;
}
if (closing) {
if (statement.depth === 0 && name === statement.name) {
put(at, ";", whole.length);
statement = null;
closes.length = 0;
skipping = 0;
continue;
}
statement.depth = Math.max(0, statement.depth - 1);
if (skipping) {
skipping--;
continue;
}
const close = closes.pop();
if (close?.trailingComma) trailing.push(at);
if (close?.text) put(at, ` ${close.text} `, whole.length);
continue;
}
if (selfClosing) continue;
statement.depth++;
if (skipping || SKIPPED.has(name)) {
skipping++;
continue;
}
let open: string | null = null;
let close: string | null = null;
let trailingComma = false;
if (name === "where") {
open = "where";
leading.push(end);
} else if (name === "set") {
open = "set";
trailingComma = true;
} else if (name === "trim") {
open = attr(attrs, "prefix");
close = attr(attrs, "suffix");
if (/\b(and|or)\b/i.test(attr(attrs, "prefixOverrides") ?? "")) leading.push(end);
trailingComma = (attr(attrs, "suffixOverrides") ?? "").includes(",");
} else if (name === "foreach") {
open = attr(attrs, "open");
close = attr(attrs, "close");
}
if (open) put(at, ` ${open} `, whole.length);
closes.push({ text: close, trailingComma });
}
if (statement && !skipping) copy(textFrom, doc.length);
for (const from of leading) {
let i = from;
while (i < out.length && /\s/.test(out[i]!)) i++;
const word = /^(and|or)\b/i.exec(out.slice(i, i + 4).join(""));
if (word) for (let k = 0; k < word[0].length; k++) out[i + k] = " ";
}
for (const before of trailing) {
let i = before - 1;
while (i >= 0 && /\s/.test(out[i]!)) i--;
if (out[i] === ",") out[i] = " ";
}
return { text: out.join(""), segments };
}
/** Whether offset `pos` is in (or right after) SQL text of the mapper. */
export function inMapperSql(sql: MapperSql, pos: number): boolean {
return sql.segments.some((s) => pos >= s.from && pos <= s.to);
}
+41 -14
Переглянути файл
@@ -20,6 +20,7 @@ import { offsetToPos } from "@/editor/lsp/positions";
import type { DbCompletion, DbCompletionTable, DbDriver } from "@/platform/ipc";
import { formatSql } from "./sql/format";
import { SqlResolver, type SqlSymbol } from "./sql/resolve";
import { useProject } from "@/platform/project";
import { consoleSchema, consoleSource, revealInTree, sourceById, useDatabase } from "./store";
/** Producer id of the console's diagnostics (Problems view, hover). */
@@ -38,18 +39,29 @@ function sourceOf(path: string): { id: string | null; driver: DbDriver; model: D
};
}
function resolver(path: string, state: EditorState): SqlResolver {
/**
* Where the SQL of a file is: its text as the SQL tools read it (the file's offsets), and
* whether an offset is in SQL. A SQL file is SQL throughout; a MyBatis mapper only in its statements.
*/
export interface SqlText {
text(state: EditorState): string;
at?(state: EditorState, pos: number): boolean;
}
export const WHOLE_FILE: SqlText = { text: (state) => state.doc.toString() };
function resolver(path: string, state: EditorState, sql: SqlText): SqlResolver {
const { driver, model } = sourceOf(path);
return new SqlResolver(state.doc.toString(), driver, model);
return new SqlResolver(sql.text(state), driver, model);
}
/** Unresolved tables / columns / aliases as error diagnostics, re-checked after edits and schema loads. */
function inspections(path: string): Extension {
function inspections(path: string, sql: SqlText): Extension {
return ViewPlugin.define((view) => {
let timer: ReturnType<typeof setTimeout> | undefined;
const run = () => {
const doc = view.state.doc;
const problems = sourceOf(path).model ? resolver(path, view.state).problems() : [];
const problems = sourceOf(path).model ? resolver(path, view.state, sql).problems() : [];
setFileDiagnostics(
path,
INSPECTIONS,
@@ -69,9 +81,18 @@ function inspections(path: string): Extension {
schedule();
// The schema model arrives (or the console is bound to another source / schema) after the editor opens.
const unsubscribe = useDatabase.subscribe((s, prev) => {
if (s.completion !== prev.completion || s.consoles !== prev.consoles || s.consoleSchemas !== prev.consoleSchemas)
if (
s.completion !== prev.completion ||
s.consoles !== prev.consoles ||
s.consoleSchemas !== prev.consoleSchemas ||
s.sources !== prev.sources
)
schedule();
});
// SQL resolution scopes can move the file to another data source.
const unsubscribeSettings = useProject.subscribe((s, prev) => {
if (s.settings !== prev.settings) schedule();
});
return {
update: (u) => {
if (u.docChanged) schedule();
@@ -79,16 +100,20 @@ function inspections(path: string): Extension {
destroy: () => {
clearTimeout(timer);
unsubscribe();
unsubscribeSettings();
setFileDiagnostics(path, INSPECTIONS, []);
},
};
});
}
function definition(path: string): ContributedDefinition {
function definition(path: string, sql: SqlText): ContributedDefinition {
return (view, pos) => {
const r = resolver(path, view.state).resolveAt(pos);
if (sql.at && !sql.at(view.state, pos)) return false;
const r = resolver(path, view.state, sql).resolveAt(pos);
const sym = r?.symbol;
// Outside SQL names, other providers (the XML language server) may know the place.
if (!sym && sql.at) return false;
const id = consoleSource(path);
const reveal = (t: DbCompletionTable, column?: string) => {
if (id) void revealInTree(id, t.schema, t.name, t.kind, column);
@@ -172,9 +197,10 @@ function symbolDoc(sym: SqlSymbol, model: DbCompletion | null): string | null {
}
}
function hover(path: string): ContributedHover {
function hover(path: string, sql: SqlText): ContributedHover {
return (state, pos) => {
const r = resolver(path, state).resolveAt(pos);
if (sql.at && !sql.at(state, pos)) return null;
const r = resolver(path, state, sql).resolveAt(pos);
const markdown = r?.symbol ? symbolDoc(r.symbol, sourceOf(path).model) : null;
return r && markdown ? { from: r.from, to: r.to, markdown } : null;
};
@@ -184,11 +210,12 @@ function formatter(path: string): ContributedFormatter {
return (state, range) => formatSql(state.doc.toString(), sourceOf(path).driver, range);
}
export function sqlSupport(path: string): Extension {
/** Inspections, navigation and documentation for the SQL of `path` (and Reformat Code for SQL files). */
export function sqlSupport(path: string, sql: SqlText = WHOLE_FILE): Extension {
const data = {
[CONTRIBUTED_DEFINITION]: definition(path),
[CONTRIBUTED_HOVER]: hover(path),
[CONTRIBUTED_FORMAT]: formatter(path),
[CONTRIBUTED_DEFINITION]: definition(path, sql),
[CONTRIBUTED_HOVER]: hover(path, sql),
...(sql === WHOLE_FILE ? { [CONTRIBUTED_FORMAT]: formatter(path) } : {}),
};
return [inspections(path), EditorState.languageData.of(() => [data])];
return [inspections(path, sql), EditorState.languageData.of(() => [data])];
}
+81 -7
Переглянути файл
@@ -56,6 +56,8 @@ import { formatted } from "./sql/format";
import { bindParams, findParams } from "./sql/params";
import { isReadOnlyQuery } from "./sql/readOnly";
import { pageFetch } from "./resultView";
import type { TableSnapshot } from "./schemaCompare";
import { resolutionScopeOf, resolutionScopesOf, type SqlResolutionScope } from "./resolutionScopes";
import { databaseRequest, invalidateDatabaseRequests, projectRequest } from "./requests";
import { tx } from "@/platform/i18n";
@@ -87,6 +89,18 @@ export interface ResultTab {
total?: number | null;
/** Kept when the console runs again (Pin Tab); results otherwise replace the console's last ones. */
pinned?: boolean;
/** Shown in the editor under its statement (In-Editor Results), not as a result tab. */
inline?: boolean;
}
/** Database › In-Editor Results: result sets show under their statements instead of in result tabs. */
export function inEditorResults(settings: unknown = useProject.getState().settings): boolean {
return (settings as { database?: { inEditorResults?: unknown } } | null)?.database?.inEditorResults === true;
}
export async function setInEditorResults(on: boolean): Promise<void> {
const settings = await call(commands.settingsSet("global", "database.inEditorResults", JSON.stringify(on)));
useProject.setState({ settings });
}
/** One line of the consoles' Output log (IDEA's Database Console output). */
@@ -130,7 +144,9 @@ export type DialogState =
/** Browse Query History of target `id`; Paste goes to console `path`. */
| { kind: "history"; id: string; path: string | null }
/** Import Data from File into a table. */
| { kind: "import"; id: string; schema: string; table: string };
| { kind: "import"; id: string; schema: string; table: string }
/** Compare Structure: `source` starts as the schema the action was invoked on. */
| { kind: "compareSchemas"; source: { id: string; schema: string } | null };
/** The schemas and tables of a data source's databases, as far as introspection has read them. */
export interface SourceCatalog {
@@ -167,6 +183,8 @@ interface DatabaseState {
separateProceduresAndFunctions: boolean;
completion: Record<string, DbCompletion>;
results: ResultTab[];
/** Results shown in the editor under their statements (In-Editor Results), oldest first. */
inline: ResultTab[];
/** Result tab id, or `OUTPUT_TAB`. */
activeResult: number | null;
output: OutputLine[];
@@ -234,6 +252,7 @@ export const useDatabase = create<DatabaseState>(() => ({
separateProceduresAndFunctions: readSeparateProceduresAndFunctions(),
completion: {},
results: [],
inline: [],
activeResult: null,
output: [],
running: {},
@@ -693,6 +712,25 @@ export async function loadTables(id: string, schema: string): Promise<void> {
}
}
/** The tables of `schema` on target `id` with their columns, indexes and foreign keys (Compare Structure). */
export async function schemaSnapshot(id: string, schema: string, signal?: AbortSignal): Promise<TableSnapshot[]> {
const tables = (await withConnection(id, () => call(commands.dbTables(id, schema)))).filter(
(t) => t.kind === "table",
);
const out: TableSnapshot[] = [];
let next = 0;
const worker = async () => {
while (next < tables.length) {
if (signal?.aborted) return;
const t = tables[next++]!;
const details = await call(commands.dbTableDetails(id, schema, t.name));
out.push({ name: t.name, kind: t.kind, ...details });
}
};
await Promise.all(Array.from({ length: Math.min(4, tables.length) }, worker));
return out;
}
export async function loadDetails(id: string, schema: string, table: string): Promise<void> {
const key = detailsKey(id, schema, table);
const current = metadataRequest(id, "details", key);
@@ -869,7 +907,10 @@ export function bindConsole(path: string, id: string | null) {
export function consoleSchema(path: string): string {
const s = useDatabase.getState();
const id = consoleSource(path);
return activeSchema(s.consoleSchemas[path], id ? s.completion[id]?.defaultSchema : undefined);
// A scope's schema applies while the console is on that scope's data source.
const scope = s.consoles[path] ? null : scopeOf(path);
const picked = s.consoleSchemas[path] ?? (scope && scope.dataSource === id ? scope.schema : undefined);
return activeSchema(picked || undefined, id ? s.completion[id]?.defaultSchema : undefined);
}
/** Sets (or clears, for `null`) the console's active schema and remembers it per console file. */
@@ -887,11 +928,26 @@ export function setConsoleSchema(path: string, schema: string | null) {
});
}
/** The data source a console / SQL file runs on: its binding, else the only data source. */
/** The SQL resolution scope of file `path` (Languages & Frameworks › SQL Resolution Scopes), if any. */
function scopeOf(path: string): SqlResolutionScope | null {
const { project, settings } = useProject.getState();
if (!project) return null;
const sources = useDatabase.getState().sources;
return resolutionScopeOf(path, project.root, resolutionScopesOf(settings), (id) =>
sources.some((x) => x.id === splitTarget(id).id),
);
}
/**
* The data source a console / SQL file runs on and resolves against: the one picked in its
* toolbar, else its SQL resolution scope's, else the only data source.
*/
export function consoleSource(path: string): string | null {
const s = useDatabase.getState();
const bound = s.consoles[path];
if (bound && s.sources.some((x) => x.id === splitTarget(bound).id)) return bound;
const scope = scopeOf(path);
if (scope) return scope.dataSource;
return s.sources.length === 1 ? (s.sources[0]!.id ?? null) : null;
}
@@ -1141,6 +1197,10 @@ export async function executeConsole(
const title = index === 1 ? tx`Result ${n}` : tx`Result ${n}-${index}`;
return { id: nextTab++, title, path, sourceId: id, schema, outcome, page: 0, pageSize };
});
if (inEditorResults()) {
useDatabase.setState((s) => ({ inline: [...s.inline, ...tabs.map((t) => ({ ...t, inline: true }))] }));
return outcomes;
}
const failed = outcomes.some((o) => o.error);
useDatabase.setState((s) => ({
results: replaceResults(s.results, path, tabs),
@@ -1282,7 +1342,7 @@ export async function openObjectDdl(id: string, schema: string, kind: DbObjectKi
/** Re-runs the statement of result tab `tabId`, replacing its rows (a plan tab explains it again). */
export async function rerunResult(tabId: number): Promise<void> {
const tab = useDatabase.getState().results.find((r) => r.id === tabId);
const tab = findResult(tabId);
if (!tab || tab.busy) return;
if (tab.plan) {
patchResult(tabId, { busy: true });
@@ -1305,8 +1365,16 @@ export function pageable(tab: ResultTab): boolean {
return !tab.plan && isReadOnlyQuery(tab.outcome.statement.text, sourceById(tab.sourceId)?.driver ?? "sqlite");
}
/** Result tab `tabId`, in the Services view or in an editor. */
export function findResult(tabId: number): ResultTab | undefined {
const st = useDatabase.getState();
return st.results.find((r) => r.id === tabId) ?? st.inline.find((r) => r.id === tabId);
}
function patchResult(tabId: number, p: Partial<ResultTab>) {
useDatabase.setState((s) => ({ results: s.results.map((r) => (r.id === tabId ? { ...r, ...p } : r)) }));
const patch = (list: ResultTab[]) =>
list.some((r) => r.id === tabId) ? list.map((r) => (r.id === tabId ? { ...r, ...p } : r)) : list;
useDatabase.setState((s) => ({ results: patch(s.results), inline: patch(s.inline) }));
}
/**
@@ -1315,7 +1383,7 @@ function patchResult(tabId: number, p: Partial<ResultTab>) {
* `rerun` also forgets the counted total.
*/
export async function loadResultPage(tabId: number, page: number, pageSize: number, rerun = false): Promise<void> {
const tab = useDatabase.getState().results.find((r) => r.id === tabId);
const tab = findResult(tabId);
if (!tab || tab.busy || tab.plan) return;
if (page > 0 && !pageable(tab)) return;
patchResult(tabId, { busy: true });
@@ -1363,7 +1431,7 @@ export function countable(tab: ResultTab): boolean {
/** Counts the rows of result tab `tabId`'s whole query (the pager's "of 501+"). */
export async function countResult(tabId: number): Promise<number | null> {
const tab = useDatabase.getState().results.find((r) => r.id === tabId);
const tab = findResult(tabId);
if (!tab || tab.busy || !countable(tab)) return null;
const text = countQuery(tab.outcome.statement.text)!;
patchResult(tabId, { busy: true });
@@ -1468,6 +1536,12 @@ export function closeResult(id: number) {
});
}
/** Closes in-editor results `ids`. */
export function closeInlineResults(ids: readonly number[]) {
if (!ids.length) return;
useDatabase.setState((s) => ({ inline: s.inline.filter((r) => !ids.includes(r.id)) }));
}
export function pinResult(id: number, pinned: boolean) {
patchResult(id, { pinned });
}
+16
Переглянути файл
@@ -389,6 +389,22 @@ export function registerDatabaseTreeActions(): () => void {
if (schema !== null) openDialog({ kind: "modifyTable", id, schema, table: null });
},
}),
tree({
id: "db.compareSchemas",
title: "Compare Structure…",
description: "Compare the tables of two schemas and write the migration SQL from one to the other",
icon: "diff-side-by-side",
keywords: ["schema compare", "diff", "migration", "compare schemas", "structure"],
run: ({ arg }) => {
const n = nodeFrom(arg);
const id = n && nodeTarget(n);
const schema = n && "schema" in n && typeof n.schema === "string" ? n.schema : null;
openDialog({
kind: "compareSchemas",
source: id ? { id, schema: schema ?? (driverOf(id) === "sqlite" ? "main" : "") } : null,
});
},
}),
tree({
id: "db.newColumn",
title: "Column",
+2
Переглянути файл
@@ -117,6 +117,7 @@ export function nodeMenu(n: DbNode | null): MenuItem[] {
navigation(),
sep,
sqlScripts(n, false),
act("db.compareSchemas", n),
sep,
act("db.drop", n, { label: "Remove Data Source…" }),
];
@@ -142,6 +143,7 @@ export function nodeMenu(n: DbNode | null): MenuItem[] {
navigation(),
sep,
sqlScripts(n, false),
...(n.kind === "schema" ? [act("db.compareSchemas", n)] : []),
...(n.kind === "schema" ? [sep, drop] : []),
];
case "table":
+9
Переглянути файл
@@ -20,6 +20,7 @@ const proc = (p: Partial<AttachableProcess> & Pick<AttachableProcess, "pid" | "k
name: p.kind,
commandLine: `${p.kind} app`,
adapter: {
unity: "unity",
java: "java-debug",
node: "js-debug",
python: "debugpy",
@@ -49,6 +50,14 @@ const list = [
];
describe("Attach to Process popup model", () => {
it("attaches the chosen Unity Editor by its exact ID without launching or using a native adapter", async () => {
const launch = await attachConfig(proc({ pid: 1234, kind: "unity", name: "Unity Editor" }), "/game");
expect(launch).toMatchObject({ adapter: "unity", request: "attach", program: null, cwd: "/game" });
expect(JSON.parse(launch.extraJson!)).toEqual({
name: "Unity Editor (1234)",
__exceptionOptions: [],
});
});
it("groups processes by debugger in IDEA's order with counts", () => {
const rows = attachRows(list, "");
expect(rows.filter((r) => r.kind === "group").map((r) => r.kind === "group" && `${r.label}:${r.count}`)).toEqual([
+1
Переглянути файл
@@ -12,6 +12,7 @@ describe("missing debug adapters", () => {
});
it("offers the managed install of a missing adapter binary", () => {
expect(missingAdapter("unity", unavailable("debug adapter `unity` not found"))?.tool).toBe("unity-debug");
const e = unavailable(
"debug adapter `js-debug` not found (`js-debug-adapter` is neither installed by OpenIDEA nor on PATH)",
);
+142
Переглянути файл
@@ -0,0 +1,142 @@
import { afterEach, beforeEach, expect, it, vi } from "vitest";
import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
import type { AttachableProcess, ProjectInfo, RunConfig } from "@/platform/ipc";
const mocks = vi.hoisted(() => ({ discover: vi.fn(), generic: vi.fn(), start: vi.fn(), install: vi.fn() }));
vi.mock("@/platform/ipc", async (original) => {
const real = await original<typeof import("@/platform/ipc")>();
return {
...real,
isTauri: () => true,
commands: {
...real.commands,
debugUnityProcesses: mocks.discover,
debugAttachableProcesses: mocks.generic,
},
};
});
vi.mock("../state", async (original) => ({
...(await original<typeof import("../state")>()),
startSession: mocks.start,
}));
import { registerAction } from "@/platform/actions";
import { useProject } from "@/platform/project";
import { openAttachPopup, installAttachAdapter } from "../attachPopup";
import { DebuggerOverlays } from "../ui/Overlays";
import { useOverlays } from "../ui/popoverStore";
const editor: AttachableProcess = {
pid: 42,
name: "Unity Editor",
commandLine: "/game",
adapter: "unity",
kind: "unity",
host: null,
port: null,
};
const ok = (data: AttachableProcess[]) => ({ status: "ok" as const, data });
function deferred() {
let resolve!: (result: ReturnType<typeof ok>) => void;
const promise = new Promise<ReturnType<typeof ok>>((r) => {
resolve = r;
});
return { promise, resolve };
}
let dispose: () => void;
beforeEach(() => {
vi.clearAllMocks();
useProject.setState({ project: { root: "/game" } as ProjectInfo });
useOverlays.setState({ attach: null });
mocks.discover.mockResolvedValue(ok([editor]));
mocks.start.mockResolvedValue(1);
mocks.install.mockResolvedValue(undefined);
dispose = registerAction({ id: "tools.install", title: "Install", run: mocks.install });
});
afterEach(() => {
cleanup();
dispose();
useOverlays.setState({ attach: null });
useProject.setState({ project: null });
});
it("selects the requested Unity process and starts a non-rerunnable attach session", async () => {
const otherEditor = { ...editor, pid: 84, commandLine: "/other-game" };
mocks.discover.mockResolvedValueOnce(ok([otherEditor, editor]));
await openAttachPopup("unity");
render(<DebuggerOverlays />);
expect(screen.getByRole("dialog", { name: "Attach to Unity Process" })).toBeTruthy();
expect(screen.getByText(/switch to Debug Mode/)).toBeTruthy();
fireEvent.keyDown(screen.getByRole("textbox", { name: "Filter processes" }), { key: "ArrowDown" });
fireEvent.click(screen.getByRole("button", { name: "Attach" }));
await waitFor(() =>
expect(mocks.start).toHaveBeenCalledWith(
expect.objectContaining({
request: "attach",
adapter: "unity",
cwd: "/game",
extraJson: expect.stringContaining("Unity Editor (42)"),
}),
{ rerunnable: false },
),
);
expect(mocks.generic).not.toHaveBeenCalled();
expect(useOverlays.getState().attach).toBeNull();
});
it("associates the selected run configuration after refreshing the picker", async () => {
const runConfig = { id: "unity-editor", name: "Unity Editor", kind: "unity-editor" } as RunConfig;
await openAttachPopup("unity", runConfig);
render(<DebuggerOverlays />);
fireEvent.click(screen.getByRole("button", { name: "Refresh" }));
await waitFor(() => expect(useOverlays.getState().attach?.processes).toEqual([editor]));
fireEvent.click(screen.getByRole("button", { name: "Attach" }));
await waitFor(() => expect(mocks.start).toHaveBeenCalledWith(expect.anything(), { rerunnable: false, runConfig }));
});
it("offers installation for a missing adapter and retries discovery afterwards", async () => {
mocks.discover.mockResolvedValueOnce({
status: "error",
error: { kind: "unavailable", message: "debug adapter `unity` not found" },
});
await openAttachPopup("unity");
render(<DebuggerOverlays />);
fireEvent.click(screen.getByRole("button", { name: "Install Unity Debugger" }));
await waitFor(() => expect(useOverlays.getState().attach?.processes).toEqual([editor]));
expect(mocks.install).toHaveBeenCalledWith(expect.objectContaining({ arg: "unity-debug" }));
});
it("does not replace a refreshed picker with an older discovery response", async () => {
const old = deferred();
mocks.discover.mockReturnValueOnce(old.promise);
const first = openAttachPopup("unity");
await openAttachPopup("unity");
old.resolve(ok([]));
await first;
expect(useOverlays.getState().attach?.processes).toEqual([editor]);
});
it("does not reopen a cancelled picker when discovery finishes", async () => {
const pending = deferred();
mocks.discover.mockReturnValueOnce(pending.promise);
const request = openAttachPopup("unity");
useOverlays.setState({ attach: null });
pending.resolve(ok([editor]));
await request;
expect(useOverlays.getState().attach).toBeNull();
});
it("does not attach to an old project's process or retry installation after switching projects", async () => {
await openAttachPopup("unity");
render(<DebuggerOverlays />);
act(() => useProject.setState({ project: { root: "/other" } as ProjectInfo }));
fireEvent.click(screen.getByRole("button", { name: "Attach" }));
expect(mocks.start).not.toHaveBeenCalled();
act(() =>
useOverlays.setState({
attach: { processes: [], error: "missing", mode: "unity", projectRoot: "/game", installTool: "unity-debug" },
}),
);
await installAttachAdapter();
expect(mocks.discover).toHaveBeenCalledTimes(1);
});
+11 -23
Переглянути файл
@@ -80,14 +80,9 @@ import { expressionAt, valueHint } from "./editor/valueTooltip";
import { mouseEvaluateTarget } from "./editor/quickEvaluate";
import { showHint } from "@/editor/lsp/hint";
import { pausedLineTargets, startInlineSmartStep } from "./editor/smartStep";
import {
openBreakpointsDialog,
openConfigChooser,
openEvaluateDialog,
openSmartStepChooser,
useOverlays,
} from "./ui/popoverStore";
import { openBreakpointsDialog, openConfigChooser, openEvaluateDialog, openSmartStepChooser } from "./ui/popoverStore";
import { tx } from "@/platform/i18n";
import { openAttachPopup } from "./attachPopup";
function isRunConfig(arg: unknown): arg is RunConfig {
return !!arg && typeof arg === "object" && "command" in arg && "args" in arg && "debugAdapter" in arg;
@@ -180,22 +175,6 @@ async function smartStepInto() {
if (!startInlineSmartStep(t.s.id, t.thread, targets)) openSmartStepChooser(t.s.id, t.thread, targets);
}
/** Opens the Attach to Process popup and loads the process list. */
export async function openAttachPopup() {
if (!isTauri()) {
notifications().notify({ group: "run", level: "warning", title: "Attaching needs the desktop app" });
return;
}
useOverlays.setState({ attach: { processes: null, error: null } });
try {
const processes = await call(commands.debugAttachableProcesses());
if (useOverlays.getState().attach) useOverlays.setState({ attach: { processes, error: null } });
} catch (e) {
if (useOverlays.getState().attach)
useOverlays.setState({ attach: { processes: [], error: errorText(e) || "Cannot list processes" } });
}
}
function cursor(): { path: string; line: number; selection: string } | null {
const ed = activeEditor();
if (!ed) return null;
@@ -891,6 +870,15 @@ export function registerDebugActions(): () => void {
description: "Attach the debugger to a running Java, Node.js, Python, Go or native process",
run: () => void openAttachPopup(),
},
{
id: "debug.attachUnity",
title: "Attach to Unity Process",
category: "Run",
icon: "debug",
hidden: true,
when: "projectOpen",
run: ({ arg }) => openAttachPopup("unity", arg as RunConfig | undefined),
},
{
id: "debug.debugInBrowser",
title: "Debug in Browser",
+10 -1
Переглянути файл
@@ -7,6 +7,7 @@ import type { AttachKind, AttachableProcess, LaunchConfig } from "@/platform/ipc
import { javaAttachConfig } from "./java";
export const KIND_LABELS: Record<AttachKind, string> = {
unity: "Unity Editor",
java: "Java (JDWP)",
node: "Node.js",
python: "Python (debugpy)",
@@ -15,7 +16,7 @@ export const KIND_LABELS: Record<AttachKind, string> = {
native: "Native (LLDB)",
};
const KIND_ORDER: AttachKind[] = ["java", "node", "python", "dotnet", "go", "native"];
const KIND_ORDER: AttachKind[] = ["unity", "java", "node", "python", "dotnet", "go", "native"];
export type AttachRow =
| { kind: "group"; key: string; label: string; count: number }
@@ -64,6 +65,14 @@ function base(p: AttachableProcess, cwd: string, extra: Record<string, unknown>)
export async function attachConfig(p: AttachableProcess, root: string): Promise<LaunchConfig> {
const skip = workflowSettings().debugger.skipLibraryCode;
switch (p.kind) {
case "unity":
return {
...base(p, root, {
name: `Unity Editor (${p.pid})`,
__exceptionOptions: [],
}),
adapter: "unity",
};
case "java":
return javaAttachConfig(
{ name: `${p.name} (${p.pid})`, module: "", hostName: p.host ?? "localhost", port: p.port! },
+44
Переглянути файл
@@ -0,0 +1,44 @@
import { executeAction } from "@/platform/actions";
import { call, commands, isTauri, type RunConfig } from "@/platform/ipc";
import { useProject } from "@/platform/project";
import { notifications } from "@/workbench/contributions";
import { missingAdapter } from "./missingAdapter";
import { useOverlays } from "./ui/popoverStore";
/** Applies only the latest request of the open popup; results for a closed or refreshed one are dropped. */
export async function openAttachPopup(mode: "all" | "unity" = "all", runConfig?: RunConfig) {
if (!isTauri()) {
notifications().notify({ group: "run", level: "warning", title: "Attaching needs the desktop app" });
return;
}
const projectRoot = useProject.getState().project?.root ?? null;
const pending = { processes: null, error: null, mode, projectRoot, runConfig };
useOverlays.setState({ attach: pending });
const current = () =>
useOverlays.getState().attach === pending && (useProject.getState().project?.root ?? null) === projectRoot;
try {
const processes = await call(
mode === "unity" ? commands.debugUnityProcesses() : commands.debugAttachableProcesses(),
);
if (current()) useOverlays.setState({ attach: { ...pending, processes } });
} catch (e) {
if (current())
useOverlays.setState({
attach: {
...pending,
processes: [],
error: e instanceof Error ? e.message : String(e),
installTool: mode === "unity" ? missingAdapter("unity", e)?.tool : undefined,
},
});
}
}
export async function installAttachAdapter() {
const state = useOverlays.getState().attach;
if (!state?.installTool) return;
await executeAction("tools.install", state.installTool);
if (useOverlays.getState().attach === state && useProject.getState().project?.root === state.projectRoot) {
await openAttachPopup(state.mode, state.runConfig);
}
}
+1
Переглянути файл
@@ -145,6 +145,7 @@ export function activate(): () => void {
useProject.subscribe((s, prev) => {
const root = s.project?.root ?? null;
if (root !== (prev.project?.root ?? null) || s.project?.trusted !== prev.project?.trusted) {
useOverlays.setState({ attach: null });
resetSessions();
loadWatches(root);
loadBreakpoints(root);
+1
Переглянути файл
@@ -8,6 +8,7 @@ import { tx } from "@/platform/i18n";
/** Adapters the tools installer can provide (adapter id → tool name). */
const INSTALLABLE: Record<string, { tool: string; title: string }> = {
unity: { tool: "unity-debug", title: "Unity Debugger is not installed" },
"kotlin-debug-adapter": { tool: "kotlin-debug-adapter", title: "The Kotlin debugger is not installed" },
netcoredbg: { tool: "netcoredbg", title: "netcoredbg is not installed" },
debugpy: { tool: "debugpy", title: "debugpy is not installed" },
+60 -4
Переглянути файл
@@ -33,6 +33,7 @@ import {
type SpecialBreakpoint,
} from "../breakpoints/special";
import { attachConfig, attachDetail, attachRows, type AttachRow } from "../attach";
import { openAttachPopup, installAttachAdapter } from "../attachPopup";
import {
exceptionGroups,
filterHint,
@@ -915,6 +916,7 @@ function AttachPopup() {
const root = useProject((s) => s.project?.root ?? null);
const [filter, setFilter] = useState("");
const [active, setActive] = useState(0);
const [installing, setInstalling] = useState(false);
const rows = useMemo(() => attachRows(state?.processes ?? [], filter), [state?.processes, filter]);
const firstItem = rows.findIndex((r) => r.kind === "process");
const activeIndex = rows[active]?.kind === "process" ? active : firstItem;
@@ -925,10 +927,11 @@ function AttachPopup() {
useOverlays.setState({ attach: null });
};
const attach = async (p: AttachableProcess) => {
if (state.projectRoot !== undefined && state.projectRoot !== root) return close();
close();
if (!root) return;
try {
await startSession(await attachConfig(p, root), { rerunnable: false });
await startSession(await attachConfig(p, root), { rerunnable: false, runConfig: state.runConfig });
} catch (e) {
notifications().notify({
group: "run",
@@ -948,8 +951,44 @@ function AttachPopup() {
}
};
return (
<Dialog open onClose={close} title="Attach to Process" width={640} position="top" aria-label="Attach to process">
<Dialog
open
onClose={close}
title={state.mode === "unity" ? "Attach to Unity Process" : "Attach to Process"}
width={640}
position="top"
aria-label={state.mode === "unity" ? "Attach to Unity Process" : "Attach to process"}
buttons={[
{
label: "Refresh",
role: "extra",
disabled: state.processes === null || installing,
onClick: () => {
setActive(0);
void openAttachPopup(state.mode, state.runConfig);
},
},
{ label: "Cancel", role: "cancel", onClick: close },
{
label: "Attach",
role: "default",
disabled: rows[activeIndex]?.kind !== "process" || installing,
onClick: () => {
const row = rows[activeIndex];
if (row?.kind === "process") void attach(row.process);
},
},
]}
>
<div className={styles.evalBody}>
{state.mode === "unity" && (
<p>
<T>
Open the project in Unity Editor, enable Editor Attaching and switch to Debug Mode. Select its process
below. Stopping debugging disconnects without closing Unity.
</T>
</p>
)}
<Input
value={filter}
onChange={(e) => {
@@ -975,7 +1014,20 @@ function AttachPopup() {
<T>Loading processes…</T>
</div>
) : state.error ? (
<div className={styles.empty}>{state.error}</div>
<div className={styles.empty}>
<div>{state.error}</div>
{state.installTool && (
<Button
disabled={installing}
onClick={() => {
setInstalling(true);
void installAttachAdapter().finally(() => setInstalling(false));
}}
>
{installing ? "Installing…" : "Install Unity Debugger"}
</Button>
)}
</div>
) : (
<List<AttachRow>
items={rows}
@@ -996,7 +1048,11 @@ function AttachPopup() {
className={styles.attachList}
empty={
<div className={styles.empty}>
{filter ? tx`No attachable processes match the filter.` : tx`No attachable processes.`}
{filter
? tx`No attachable processes match the filter.`
: state.mode === "unity"
? tx`No Unity Editor processes found. Open Unity Editor, then refresh.`
: tx`No attachable processes.`}
</div>
}
renderItem={(r) =>
Loaded 100 of 124 files, more files were not shown because too many files have changed in this diff. Show more