дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-16 06:35:40 +02:00
Порівняти коміти
21
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
e87495d7b1 | ||
|
|
92dd70f08b | ||
|
|
484bbfc704 | ||
|
|
0b097808f1 | ||
|
|
6cc4b3779c | ||
|
|
7d9efa1997 | ||
|
|
af2e45883d | ||
|
|
17e11b7904 | ||
|
|
22aa1edd61 | ||
|
|
07c862c785 | ||
|
|
b60dad7076 | ||
|
|
148e45745a | ||
|
|
3287061ea1 | ||
|
|
223beeb374 | ||
|
|
8b9ad2e9d1 | ||
|
|
a5306bade3 | ||
|
|
aa8822d9a3 | ||
|
|
5fca9c9ed0 | ||
|
|
83805734bf | ||
|
|
0b3d1d67d9 | ||
|
|
53a26b95a4 |
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).
|
||||
|
||||
|
||||
@@ -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)。
|
||||
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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};
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
@@ -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() }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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")]
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -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"));
|
||||
}
|
||||
}
|
||||
@@ -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));
|
||||
}
|
||||
@@ -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> {
|
||||
|
||||
@@ -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
|
||||
});
|
||||
|
||||
@@ -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
|
||||
})
|
||||
|
||||
@@ -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> {
|
||||
|
||||
@@ -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]);
|
||||
}
|
||||
}
|
||||
@@ -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}"
|
||||
);
|
||||
}
|
||||
@@ -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"),
|
||||
|
||||
@@ -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 } }
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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"] {
|
||||
|
||||
@@ -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()) })
|
||||
|
||||
@@ -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()));
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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(""", "\"").replace("'", "'").replace("<", "<").replace(">", ">").replace("&", "&")
|
||||
}
|
||||
|
||||
/// 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")));
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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]`
|
||||
|
||||
|
||||
@@ -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]`
|
||||
|
||||
|
||||
@@ -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);
|
||||
});
|
||||
@@ -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(),
|
||||
},
|
||||
});
|
||||
@@ -0,0 +1,9 @@
|
||||
<!doctype html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
</head>
|
||||
<body>
|
||||
<script type="module" src="./inlayRequests.fixture.ts"></script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -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");
|
||||
});
|
||||
@@ -0,0 +1,6 @@
|
||||
id = "gherkin"
|
||||
name = "Gherkin"
|
||||
extensions = ["feature"]
|
||||
line-comment = "#"
|
||||
indent = { tab-size = 2, insert-spaces = true }
|
||||
ui-mode = "Gherkin"
|
||||
@@ -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"
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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(())
|
||||
}
|
||||
@@ -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")]
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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"));
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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();
|
||||
});
|
||||
});
|
||||
@@ -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)]);
|
||||
}
|
||||
@@ -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"],
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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"]);
|
||||
});
|
||||
});
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
|
||||
@@ -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}
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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),
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
@@ -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 />
|
||||
|
||||
@@ -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,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" }));
|
||||
}
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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("");
|
||||
});
|
||||
});
|
||||
@@ -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) => {
|
||||
|
||||
@@ -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 (
|
||||
|
||||
@@ -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}>
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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>
|
||||
);
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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>
|
||||
);
|
||||
}
|
||||
@@ -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) },
|
||||
|
||||
@@ -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();
|
||||
});
|
||||
});
|
||||
@@ -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",
|
||||
|
||||
@@ -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);
|
||||
});
|
||||
});
|
||||
@@ -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),
|
||||
];
|
||||
}
|
||||
@@ -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");
|
||||
});
|
||||
});
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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");
|
||||
});
|
||||
});
|
||||
@@ -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` : "";
|
||||
}
|
||||
@@ -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)),
|
||||
});
|
||||
}
|
||||
@@ -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 > 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);
|
||||
});
|
||||
});
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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])];
|
||||
}
|
||||
@@ -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 });
|
||||
}
|
||||
@@ -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",
|
||||
|
||||
@@ -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":
|
||||
|
||||
@@ -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([
|
||||
|
||||
@@ -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)",
|
||||
);
|
||||
|
||||
@@ -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);
|
||||
});
|
||||
@@ -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",
|
||||
|
||||
@@ -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! },
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
|
||||
@@ -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" },
|
||||
|
||||
@@ -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
Reference in new issue
Заблокувати користувача