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

..
Автор SHA1 Повідомлення Дата
l0ng-ai 55a19bbbe1 feat(build): read Eclipse projects without a build tool
An Eclipse project's .classpath now gives its roots: source folders
(tests by their test attribute) and the output folder, excluded. Maven
and Gradle builds keep owning the model when present.

Builds of such a project use the .classpath libraries, and the web content
folder (the wb-resource deployed at / in
.settings/org.eclipse.wst.common.component, or a WebContent / WebRoot /
web / src/main/webapp folder holding WEB-INF/web.xml) acts as the Web facet
when none is configured. A web project with no artifacts gets
<name>:war exploded, which Build Artifacts lays out and Tomcat deploys.

Part of #3571
2026-11-16 10:02:02 +08:00
84 змінених файлів з 147 додано та 3072 видалено

No files matched your search

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

До

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

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

Після

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

Створено
+6 -131
Переглянути файл
@@ -199,7 +199,7 @@ dependencies = [
"wayland-backend",
"wayland-client",
"wayland-protocols",
"zbus 5.19.0",
"zbus",
]
[[package]]
@@ -5722,20 +5722,6 @@ 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"
@@ -6008,20 +5994,6 @@ 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"
@@ -6694,7 +6666,6 @@ dependencies = [
"tauri-build",
"tauri-plugin-dialog",
"tauri-plugin-mcp-bridge",
"tauri-plugin-notification",
"tauri-plugin-opener",
"tauri-plugin-single-instance",
"tauri-plugin-updater",
@@ -8182,7 +8153,7 @@ dependencies = [
"once_cell",
"serde",
"sha2 0.11.1",
"zbus 5.19.0",
"zbus",
]
[[package]]
@@ -9458,26 +9429,6 @@ 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"
@@ -9497,7 +9448,7 @@ dependencies = [
"thiserror 2.0.21",
"url",
"windows",
"zbus 5.19.0",
"zbus",
]
[[package]]
@@ -9513,7 +9464,7 @@ dependencies = [
"tokio",
"tracing",
"windows-sys 0.61.2",
"zbus 5.19.0",
"zbus",
]
[[package]]
@@ -9696,17 +9647,6 @@ 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"
@@ -12197,38 +12137,11 @@ dependencies = [
"uuid",
"windows-sys 0.61.2",
"winnow 1.0.4",
"zbus_macros 5.19.0",
"zbus_macros",
"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"
@@ -12237,7 +12150,7 @@ checksum = "74801d001b9e7729adb4f1825b67b398185fed424749aa3d8bacf70417137d9a"
dependencies = [
"keyring-core",
"secret-service",
"zbus 5.19.0",
"zbus",
]
[[package]]
@@ -12255,18 +12168,6 @@ 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"
@@ -12278,19 +12179,6 @@ 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"
@@ -12447,19 +12335,6 @@ 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-3.png" alt="WeChat group QR code" width="200">
<img src=".github/assets/wechat-group.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-3.png" alt="WeChat grubu QR kodu" width="200">
<img src=".github/assets/wechat-group.png" alt="WeChat grubu QR kodu" width="200">
- Katkıda bulunmak için: [CONTRIBUTING.md](CONTRIBUTING.md) ve [katkıcı belgeleri](https://openidea.sh/en/contribute/setup).
+1 -1
Переглянути файл
@@ -66,7 +66,7 @@ WebAssembly 组件运行;主题、图标主题和语言无需编写代码。
- [Discord](https://discord.gg/2Zy4yn7gP):提问、反馈和版本发布消息。
- 微信群,扫码加入:
<img src=".github/assets/wechat-group-3.png" alt="微信群二维码" width="200">
<img src=".github/assets/wechat-group.png" alt="微信群二维码" width="200">
- 参与贡献:参见 [CONTRIBUTING.md](CONTRIBUTING.md) 和[贡献者文档](https://openidea.sh/zh/contribute/setup)。
+1 -32
Переглянути файл
@@ -135,8 +135,6 @@ 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.
@@ -419,7 +417,6 @@ 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();
@@ -1698,28 +1695,6 @@ 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();
@@ -1822,11 +1797,8 @@ impl Task {
}
match (next, result) {
(Some(queued), _) => prompt = queued.prompt,
(None, Ok(stop)) => {
(None, Ok(_)) => {
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),
@@ -1897,7 +1869,6 @@ 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.
@@ -2529,7 +2500,6 @@ 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
@@ -2613,7 +2583,6 @@ impl Task {
});
self.permissions.lock().insert(id, tx);
self.set_status(AgentStatus::NeedsInput, None);
self.emit_attention_if_input_pending();
let reply = rx.recv().ok().flatten();
let (response, chosen) = elicitation::answer(&form, reply.as_deref());
self.settle(entry, chosen);
-15
Переглянути файл
@@ -5,15 +5,6 @@ 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 {
@@ -675,12 +666,6 @@ pub enum AgentEvent {
},
/// The installed or configured agent providers changed.
Providers,
/// The task needs attention once (finished turn, explicit input, or failure).
Attention {
task: String,
event_id: String,
reason: AgentAttentionReason,
},
}
pub use ide_core::settings::{AgentMcpServer, McpTransport};
-174
Переглянути файл
@@ -3619,177 +3619,3 @@ 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();
}
+1 -11
Переглянути файл
@@ -71,8 +71,6 @@ 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>>,
@@ -510,7 +508,6 @@ impl Default for Settings {
agent_security: AgentSecuritySettings::default(),
scopes: Vec::new(),
file_colors: FileColorSettings::default(),
database: DatabaseSettings::default(),
plugins: BTreeMap::new(),
}
}
@@ -650,20 +647,13 @@ 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, system_notifications: true, groups: BTreeMap::new() }
Self { balloons: true, sound: false, groups: BTreeMap::new() }
}
}
-24
Переглянути файл
@@ -241,30 +241,6 @@ impl Default for LogLevelColors {
}
}
/// Database settings: Query Execution and SQL Resolution Scopes.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct DatabaseSettings {
/// A console's result sets show under the statements that produced them, in the editor,
/// instead of in the Services view's result tabs.
pub in_editor_results: bool,
/// Languages & Frameworks › SQL Resolution Scopes: the data source SQL in a file or folder
/// resolves against (completion, inspections, navigation), most specific path first.
pub resolution_scopes: Vec<SqlResolutionScope>,
}
/// One row of SQL Resolution Scopes.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct SqlResolutionScope {
/// Project-relative file or folder, `/`-separated; empty for the whole project.
pub path: String,
/// Data source id.
pub data_source: String,
/// Schema unqualified names resolve in; empty for the data source's default.
pub schema: String,
}
/// Build, Execution, Deployment › Console.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
-6
Переглянути файл
@@ -120,12 +120,6 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
"stdio",
"Install GDB 14 or newer (apt install gdb, dnf install gdb, brew install gdb)",
),
"unity" => cfg(
"unity-debug",
&[],
"stdio",
"Install Unity Debugger in Settings > Language Servers, or configure the unity-debug tool path",
),
"rdbg" => cfg("rdbg", &["-O", "--port", PORT_PLACEHOLDER, "-c"], "tcp", "gem install debug"),
// A jdtls bundle: the session is started through jdtls and reached via `debugServer`.
"java-debug" => cfg(
-1
Переглянути файл
@@ -12,7 +12,6 @@ use std::path::Path;
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AttachKind {
Unity,
Java,
Node,
Python,
-15
Переглянути файл
@@ -19,7 +19,6 @@ mod jvm_memory;
pub mod kotlin;
pub mod kotlin_lsp;
mod session;
pub mod unity;
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
use connection::{Connection, DapError};
@@ -1122,16 +1121,6 @@ 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
@@ -1213,10 +1202,6 @@ 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(())
}
+2 -15
Переглянути файл
@@ -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, Instant};
use std::time::Duration;
use tokio::io::{AsyncRead, AsyncReadExt};
use tokio::process::Child;
use tokio::sync::{mpsc, watch};
@@ -116,7 +116,6 @@ 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
@@ -271,7 +270,6 @@ 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()),
}
}
@@ -718,15 +716,6 @@ 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);
}
@@ -735,9 +724,7 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
match event {
"initialized" => {
s.initialized.send_replace(true);
if s.adapter != "unity" {
s.emit(DebugEvent::Initialized);
}
s.emit(DebugEvent::Initialized);
}
"stopped" => {
let all = body.get("allThreadsStopped").and_then(Value::as_bool).unwrap_or(false);
+2 -47
Переглянути файл
@@ -158,7 +158,6 @@ 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.
@@ -199,7 +198,6 @@ impl Default for Script {
close_during_startup: false,
gdb15_starts_at_launch: false,
launch_after_configuration: false,
empty_thread_responses: 0,
accept: &[],
custom: None,
}
@@ -246,8 +244,6 @@ 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;
@@ -272,14 +268,13 @@ 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": !unity,
"supportsConfigurationDoneRequest": true,
"supportsCompletionsRequest": true,
"supportsTerminateRequest": script.supports_terminate,
"supportsSetVariable": true,
@@ -298,15 +293,8 @@ 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;
@@ -460,14 +448,7 @@ 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" => {
thread_requests += 1;
if thread_requests <= script.empty_thread_responses {
ok!(msg, json!({"threads": []}));
} else {
ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]}));
}
}
"threads" => ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]})),
"stackTrace" => ok!(
msg,
json!({"stackFrames": [
@@ -897,32 +878,6 @@ async fn stop_terminates_and_disconnects() {
assert!(h.manager.threads(id).await.is_err());
}
#[tokio::test]
async fn unity_attach_waits_for_mono_and_disconnects_without_terminating_editor() {
let h = harness(Script { empty_thread_responses: 2, ..Script::default() });
h.manager.set_breakpoints(PathBuf::from("/p/a.cs"), vec![bp(4)]).await.unwrap();
let start = h.start(LaunchConfig {
adapter: "unity".into(),
request: "attach".into(),
program: None,
extra_json: Some(json!({ "name": "Unity Editor (42)", "__exceptionOptions": [] }).to_string()),
..config()
});
let ready = async {
h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;
let commands = h.commands();
let before_breakpoints = commands.iter().take_while(|c| *c != "setBreakpoints");
assert!(before_breakpoints.filter(|c| *c == "threads").count() >= 3);
assert!(commands.iter().any(|c| c == "setBreakpoints"));
};
let (id, ()) = tokio::join!(start, ready);
let id = id.unwrap();
assert_eq!(h.request("attach")["arguments"]["name"], "Unity Editor (42)");
h.manager.stop(id).await.unwrap();
assert!(!h.commands().iter().any(|c| c == "launch" || c == "terminate"));
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], false);
}
#[tokio::test]
async fn concurrent_sessions_are_independent() {
let h = harness(Script::default());
-187
Переглянути файл
@@ -1,187 +0,0 @@
//! Lists the Unity Editors to attach to through UnityDebug's discovery (`unity-debug list`).
use crate::{
adapter,
attach::{AttachKind, AttachableProcess},
};
use ide_core::{IdeError, IdeResult};
use std::{path::PathBuf, process::Stdio, time::Duration};
/// Waits until Mono reports its threads.
pub(crate) async fn wait_for_threads(session: &crate::session::Session) -> IdeResult<()> {
tokio::time::timeout(Duration::from_secs(20), async {
loop {
let body = session.conn.request_timeout("threads", serde_json::json!({}), Duration::from_secs(5)).await?;
if body.get("threads").and_then(serde_json::Value::as_array).is_some_and(|t| !t.is_empty()) {
return Ok(());
}
tokio::time::sleep(Duration::from_millis(100)).await;
}
})
.await
.map_err(|_| {
IdeError::unavailable(
"Unity debugger did not become ready. Enable Editor Attaching and Debug Mode in Unity, then retry.",
)
})?
}
// Mono binds breakpoints asynchronously and resumes threads itself during startup: wait for that burst to end.
pub(crate) async fn settle_startup(session: &crate::session::Session) {
*session.unity_startup_activity.lock() = std::time::Instant::now();
let _ = tokio::time::timeout(Duration::from_secs(3), async {
while session.unity_startup_activity.lock().elapsed() < Duration::from_secs(1) {
tokio::time::sleep(Duration::from_millis(50)).await;
}
})
.await;
}
pub fn require_runtime(cwd: &std::path::Path) -> IdeResult<()> {
if cfg!(unix) && ide_core::tool_path::find_command("mono", &ide_core::tool_path::search_path(), cwd).is_none() {
return Err(IdeError::unavailable(
"Unity Debugger requires Mono. Install Mono, make sure mono is on PATH, then refresh the Unity process list.",
));
}
Ok(())
}
const NOT_INSTALLED: &str = "debug adapter `unity` not found. Install Unity Debugger in Settings > Language Servers or configure the unity-debug tool path";
pub async fn editors(command: Option<String>, cwd: PathBuf) -> IdeResult<Vec<AttachableProcess>> {
require_runtime(&cwd)?;
let command = command.unwrap_or_else(|| "unity-debug".into());
let lookup = command.clone();
let dir = cwd.clone();
let binary = tokio::task::spawn_blocking(move || adapter::resolve_binary(&lookup, &dir))
.await
.map_err(|e| IdeError::internal(e.to_string()))?
.ok_or_else(|| IdeError::unavailable(NOT_INSTALLED))?;
let mut cmd = tokio::process::Command::new(binary);
ide_core::process::prepare(cmd.as_std_mut());
cmd.arg("list")
.current_dir(&cwd)
.env("PATH", ide_core::tool_path::search_path())
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
let out = tokio::time::timeout(Duration::from_secs(15), cmd.output())
.await
.map_err(|_| {
IdeError::unavailable("Unity process discovery timed out. Check that Unity Editor is responsive.")
})?
.map_err(|e| IdeError::unavailable(format!("Cannot start Unity process discovery: {e}")))?;
if !out.status.success() {
return Err(IdeError::unavailable(format!(
"Unity process discovery failed: {}",
String::from_utf8_lossy(&out.stderr).trim()
)));
}
let mut rows = parse_editors(&String::from_utf8_lossy(&out.stdout));
#[cfg(windows)]
if !rows.is_empty() {
match editor_process_ids() {
Ok(editors) => rows.retain(|p| editors.contains(&p.pid)),
Err(error) => tracing::warn!(%error, "Unity process filtering failed; using adapter discovery results"),
}
}
// The Editor of the open project comes first; the user picks which one to attach to.
let path = cwd.join("Library/EditorInstance.json");
let pid = std::fs::File::open(path).ok().and_then(|file| {
use std::io::Read;
let json: serde_json::Value = serde_json::from_reader(file.take(4096)).ok()?;
json.get("process_id")?.as_u64().and_then(|n| u32::try_from(n).ok())
});
for row in &mut rows {
if Some(row.pid) == pid {
row.command_line = cwd.to_string_lossy().into_owned();
}
}
rows.sort_by_key(|p| Some(p.pid) != pid);
Ok(rows)
}
#[cfg(windows)]
fn editor_process_ids() -> IdeResult<std::collections::HashSet<u32>> {
use std::collections::HashMap;
use windows_sys::Win32::{
Foundation::{CloseHandle, INVALID_HANDLE_VALUE},
System::Diagnostics::ToolHelp::{
CreateToolhelp32Snapshot, PROCESSENTRY32W, Process32FirstW, Process32NextW, TH32CS_SNAPPROCESS,
},
};
let mut unity = HashMap::new();
// The adapter also finds the asset import worker processes: keep the Unity processes whose parent isn't Unity.
unsafe {
let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if snapshot == INVALID_HANDLE_VALUE {
return Err(std::io::Error::last_os_error().into());
}
let mut entry = PROCESSENTRY32W { dwSize: std::mem::size_of::<PROCESSENTRY32W>() as u32, ..std::mem::zeroed() };
let mut found = Process32FirstW(snapshot, &mut entry);
if found == 0 {
let error = std::io::Error::last_os_error();
CloseHandle(snapshot);
return Err(error.into());
}
while found != 0 {
let end = entry.szExeFile.iter().position(|c| *c == 0).unwrap_or(entry.szExeFile.len());
let name = String::from_utf16_lossy(&entry.szExeFile[..end]);
if name.eq_ignore_ascii_case("Unity.exe") {
unity.insert(entry.th32ProcessID, entry.th32ParentProcessID);
}
found = Process32NextW(snapshot, &mut entry);
}
CloseHandle(snapshot);
}
Ok(unity.iter().filter_map(|(&pid, parent)| (!unity.contains_key(parent)).then_some(pid)).collect())
}
pub fn parse_editors(output: &str) -> Vec<AttachableProcess> {
let mut editors = Vec::new();
for line in output.lines() {
let line = line.trim().trim_start_matches('\u{feff}');
if !line.starts_with("Unity Editor (") {
continue;
}
// 3.0.1 prints `Unity Editor (Unity) (123)`; later versions append the project name.
let Some((name, pid, project)) = line.match_indices(" (").find_map(|(at, _)| {
let (id, project) = line[at + 2..].split_once(')')?;
let pid = id.parse::<u32>().ok().filter(|n| *n > 0)?;
Some((&line[..at], pid, project))
}) else {
continue;
};
if editors.iter().any(|p: &AttachableProcess| p.pid == pid) {
continue;
}
editors.push(AttachableProcess {
pid,
name: "Unity Editor".into(),
command_line: if project.trim().is_empty() { name.into() } else { project.trim().into() },
kind: AttachKind::Unity,
adapter: "unity".into(),
host: None,
port: None,
});
}
editors.sort_by(|a, b| a.command_line.cmp(&b.command_line).then(a.pid.cmp(&b.pid)));
editors
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_editor_ids_and_projects_without_mistaking_players_or_logs_for_editors() {
let rows = parse_editors(
"\u{feff}Unity Editor (Unity) (42) Game (Test)\r\nUnity Editor (7) My Game\nUnity Editor (42) duplicate\nWindowsPlayer (123) Player\nUnity Hub (44)\nUnity Editor (invalid)\nUnity Editor (0)\nlog text",
);
assert_eq!(rows.len(), 2);
assert_eq!((rows[0].pid, rows[0].command_line.as_str()), (42, "Game (Test)"));
assert_eq!(rows[1].pid, 7);
assert!(rows.iter().all(|p| p.kind == AttachKind::Unity && p.adapter == "unity"));
}
}
-187
Переглянути файл
@@ -1,187 +0,0 @@
//! 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));
}
-45
Переглянути файл
@@ -12,25 +12,6 @@ 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"
@@ -119,26 +100,12 @@ 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> {
@@ -493,17 +460,6 @@ 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(
@@ -708,7 +664,6 @@ 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
});
+2 -41
Переглянути файл
@@ -338,15 +338,6 @@ 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)]
{
@@ -356,8 +347,7 @@ pub fn link_executable_with_runtime(
}
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 = runtime.or_else(|| target.extension().is_some_and(|e| e == "js").then_some("node"));
let runner = runner.map(|r| format!("{r} ")).unwrap_or_default();
let runner = if target.extension().is_some_and(|e| e == "js") { "node " } else { "" };
fs::write(&link, format!("#!/bin/sh\nexec {runner}'{quoted}' \"$@\"\n"))?;
make_executable(&link)?;
make_executable(target)?;
@@ -366,8 +356,7 @@ pub fn link_executable_with_runtime(
#[cfg(not(unix))]
{
let link = bin_dir.join(format!("{command}.cmd"));
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();
let runner = if target.extension().is_some_and(|e| e == "js") { "node " } else { "" };
fs::write(&link, format!("@echo off\r\n{runner}\"{}\" %*\r\n", cmd_path(bin_dir, target)))?;
Ok(link)
}
@@ -521,34 +510,6 @@ 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"] {
+1 -13
Переглянути файл
@@ -1296,14 +1296,6 @@ 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),
@@ -1450,11 +1442,7 @@ impl Tools {
} else {
archive::make_executable(&target)?;
if self.exe_in(&bin, main).as_deref() != Some(target.as_path()) {
if spec.name == "unity-debug" && cfg!(unix) {
archive::link_executable_with_runtime(&bin, main, &target, Some("mono"))?;
} else {
archive::link_executable(&bin, main, &target)?;
}
archive::link_executable(&bin, main, &target)?;
}
}
self.write_manifest(spec.name, &Manifest { version: Some(dl.version.clone()), source: Some(dl.url.clone()) })
-28
Переглянути файл
@@ -20,8 +20,6 @@ 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.
@@ -82,7 +80,6 @@ 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",
}
}
@@ -134,29 +131,6 @@ 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",
@@ -1190,8 +1164,6 @@ mod tests {
fn registry_names_match_language_configs() {
let langs = ide_language::LanguageRegistry::load(None).unwrap().all();
let mut known = std::collections::HashSet::new();
// The Unity debugger comes with Unity projects, apart from the C# debugger.
known.insert(("unity-debug".to_owned(), "unity-debug".to_owned()));
for l in &langs {
for s in &l.language_servers {
known.insert((s.name.clone(), s.command.clone()));
-18
Переглянути файл
@@ -49,24 +49,6 @@ 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] {
+1 -21
Переглянути файл
@@ -30,14 +30,12 @@ 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]; 6] = [
const USER_ONLY: [&[&str]; 5] = [
&["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.
@@ -1221,22 +1219,4 @@ 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);
}
}
+6 -7
Переглянути файл
@@ -152,13 +152,12 @@ Sub-tables such as `[editor.general]`, `[editor.appearance]`, `[editor.completio
### `[notifications]`
| 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. |
| 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. |
### `[terminal]`
+6 -7
Переглянути файл
@@ -152,13 +152,12 @@ exclude = ["**/.git", "**/node_modules", "**/target", "**/dist"]
### `[notifications]`
| 键 | 默认值 | 说明 |
| --------------------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `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` | 同时在通知工具窗口中列出。 |
| 键 | 默认值 | 说明 |
| --------------------------- | ----------- | --------------------------------------------------- |
| `balloons` | `true` | **显示气球通知**。 |
| `sound` | `false` | **播放声音**。 |
| `groups.<group-id>.display` | `"balloon"` | 每个分组的弹出方式:`balloon`、`sticky` 或 `none`。 |
| `groups.<group-id>.log` | `true` | 同时在通知工具窗口中列出。 |
### `[terminal]`
-1
Переглянути файл
@@ -16,7 +16,6 @@ dunce.workspace = true
[dependencies]
tauri = { version = "2", features = [] }
tauri-plugin-opener = "2"
tauri-plugin-notification = "2.8.1"
tauri-plugin-dialog = { version = "2", default-features = false, features = ["xdg-portal"] }
tauri-plugin-mcp-bridge = "0.13"
tauri-plugin-window-state = "2"
-1
Переглянути файл
@@ -16,7 +16,6 @@
"core:webview:allow-set-webview-background-color",
"opener:default",
"opener:allow-reveal-item-in-dir",
"notification:default",
"dialog:default",
"core:window:allow-destroy",
"core:window:allow-close",
-9
Переглянути файл
@@ -348,15 +348,6 @@ pub async fn debug_free_port(window: Window, state: State<'_, AppState>) -> IdeR
ide_host::ops::debug::debug_free_port(&state.host, window.label()).await
}
#[tauri::command]
#[specta::specta]
pub async fn debug_unity_processes(
window: tauri::Window,
state: State<'_, AppState>,
) -> IdeResult<Vec<attach::AttachableProcess>> {
ide_host::ops::debug::debug_unity_processes(&state.host, window.label()).await
}
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
#[tauri::command]
-3
Переглянути файл
@@ -35,7 +35,6 @@ pub mod lsp;
pub mod mcp;
pub mod nav;
pub mod notebook;
pub mod notification;
pub mod perf;
pub mod plugin;
pub mod profiler;
@@ -200,7 +199,6 @@ 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,
@@ -553,7 +551,6 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
debug::debug_data_breakpoint_info,
debug::debug_attachable_processes,
debug::debug_free_port,
debug::debug_unity_processes,
debug::debug_listen_for_jvm,
debug::debug_redefine_classes,
debug::debug_jvm_memory_classes,
-12
Переглянути файл
@@ -1,12 +0,0 @@
//! 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(())
}
+1 -6
Переглянути файл
@@ -26,7 +26,6 @@ mod relaunch;
mod remote_container;
mod remote_dev;
mod remote_wsl;
mod system_notifications;
mod state;
mod theme_frame;
@@ -122,10 +121,7 @@ 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_notification::init())
.plugin(tauri_plugin_dialog::init());
let app = app.plugin(tauri_plugin_opener::init()).plugin(tauri_plugin_dialog::init());
#[cfg(target_os = "linux")]
let app = app.plugin(linux_window_state::plugin());
#[cfg(not(target_os = "linux"))]
@@ -224,7 +220,6 @@ pub fn run() {
windows::report_cli_error(app.handle(), error);
}
app.manage(application_focus::ApplicationFocus::default());
system_notifications::init(app.handle());
#[cfg(target_os = "macos")]
macos::intercept_system_quit(app.handle());
#[cfg(target_os = "macos")]
-1
Переглянути файл
@@ -179,7 +179,6 @@ impl AppState {
/// Called on the event-loop thread (window destruction, the `close_project`
/// command), so it must not wait for the project's workers to shut down.
pub fn close_project(&self, window: &str) {
crate::system_notifications::clear_window(window);
self.remote_dev.disconnect(window);
self.host.close_project_detached(window);
}
-150
Переглянути файл
@@ -1,150 +0,0 @@
//! OS notification centre toasts for in-IDE balloons while OpenIDEA is unfocused.
//!
//! Driven by `show_system_notification` from the notification store. Honour
//! global `[notifications].systemNotifications`; suppressed while any window is
//! active. Click focuses the window that raised the toast — balloon actions stay
//! in the IDE.
use parking_lot::Mutex;
use std::collections::HashMap;
use std::sync::LazyLock;
use std::sync::atomic::{AtomicBool, AtomicI32, Ordering};
use tauri::{AppHandle, Manager};
use tauri_plugin_notification::{NotificationExt, PermissionState};
const MAX_TARGETS: usize = 64;
struct State {
ready: AtomicBool,
next_id: AtomicI32,
/// Native notification id → owning window label.
targets: Mutex<HashMap<i32, String>>,
}
impl State {
fn new() -> Self {
Self { ready: AtomicBool::new(false), next_id: AtomicI32::new(1), targets: Mutex::new(HashMap::new()) }
}
fn put_target(&self, id: i32, window: String) {
let mut targets = self.targets.lock();
targets.insert(id, window);
while targets.len() > MAX_TARGETS {
let oldest = targets.keys().copied().min();
if let Some(oldest) = oldest {
targets.remove(&oldest);
} else {
break;
}
}
}
fn take_target(&self, id: i32) -> Option<String> {
self.targets.lock().remove(&id)
}
fn clear_window(&self, window: &str) {
self.targets.lock().retain(|_, w| w != window);
}
}
static STATE: LazyLock<State> = LazyLock::new(State::new);
/// Registers the notification plugin's activation handler once.
pub fn init(app: &AppHandle) {
if STATE.ready.swap(true, Ordering::AcqRel) {
return;
}
let handle = app.clone();
if let Err(e) = app.notification().on_action(move |performed| {
if performed.action_id() != "tap" {
return;
}
let Some(n) = performed.notification() else { return };
activate(&handle, n.id());
}) {
tracing::warn!("system notifications: cannot register action handler: {e}");
STATE.ready.store(false, Ordering::Release);
}
}
/// Project closed or window replaced: drop click targets for that owner.
pub fn clear_window(window: &str) {
STATE.clear_window(window);
}
/// Show an OS toast when the setting is on and no OpenIDEA window is focused.
pub fn show(app: &AppHandle, window: &str, title: String, body: String) {
let owner = crate::state::AppState::owner_window(window).to_owned();
let app = app.clone();
let _ = app.clone().run_on_main_thread(move || deliver(&app, &owner, &title, &body));
}
fn deliver(app: &AppHandle, window: &str, title: &str, body: &str) {
let Some(state) = app.try_state::<crate::state::AppState>() else { return };
let settings = state.host.global_settings.effective();
if !settings.notifications.system_notifications {
return;
}
if crate::application_focus::application_active(app) {
return;
}
init(app);
if !STATE.ready.load(Ordering::Acquire) {
return;
}
// Desktop always reports Granted without an OS prompt (not proof of visible delivery).
let granted = app
.notification()
.permission_state()
.ok()
.or_else(|| app.notification().request_permission().ok())
.is_some_and(|s| s == PermissionState::Granted);
if !granted {
return;
}
let id = STATE.next_id.fetch_add(1, Ordering::Relaxed);
STATE.put_target(id, window.to_owned());
let mut builder = app.notification().builder().id(id).title(title).body(body);
if settings.notifications.sound {
builder = builder.sound("default");
}
if let Err(e) = builder.show() {
tracing::debug!("system notification not shown: {e}");
STATE.take_target(id);
}
}
fn activate(app: &AppHandle, id: i32) {
let Some(window_label) = STATE.take_target(id) else { return };
let app = app.clone();
let _ = app.clone().run_on_main_thread(move || {
let Some(window) = app.get_webview_window(&window_label) else { return };
let _ = window.unminimize();
let _ = window.show();
let _ = window.set_focus();
});
}
#[cfg(test)]
mod tests {
use super::*;
use ide_core::settings::NotificationSettings;
#[test]
fn settings_default_on() {
assert!(NotificationSettings::default().system_notifications);
}
#[test]
fn clear_window_drops_targets() {
let state = State::new();
state.put_target(1, "w1".into());
state.put_target(2, "w2".into());
state.clear_window("w1");
assert!(state.take_target(1).is_none());
assert_eq!(state.take_target(2).as_deref(), Some("w2"));
}
}
-2
Переглянути файл
@@ -165,7 +165,6 @@ 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
@@ -536,7 +535,6 @@ 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
+2 -40
Переглянути файл
@@ -331,8 +331,6 @@ 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`.
@@ -1337,7 +1335,6 @@ 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.
@@ -1895,9 +1892,6 @@ 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,
@@ -2104,9 +2098,7 @@ 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" } |
/** The task needs attention once (finished turn, explicit input, or failure). */
{ type: "attention"; task: string; eventId: string; reason: AgentAttentionReason };
{ type: "providers" };
/** A form the agent asks the user to fill in (ACP `elicitation/create`, form mode). */
export type AgentForm = {
@@ -2738,7 +2730,7 @@ export type AskpassKind =
/** Yes / no (an unknown host key); answered with `yes` or `no`. */
"confirm";
export type AttachKind = "unity" | "java" | "node" | "python" | "dotnet" | "go" | "native";
export type AttachKind = "java" | "node" | "python" | "dotnet" | "go" | "native";
export type AttachableProcess = {
pid: number,
@@ -3862,20 +3854,6 @@ 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. */
@@ -7979,8 +7957,6 @@ 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 },
};
@@ -9952,8 +9928,6 @@ 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 } },
};
@@ -10024,8 +9998,6 @@ 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 } },
};
@@ -10174,16 +10146,6 @@ 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
+11
Переглянути файл
@@ -35,6 +35,7 @@ import {
import {
age,
appendEntry,
attentionChange,
branchLabel,
entriesKey,
findSubagent,
@@ -446,6 +447,16 @@ describe("agents model", () => {
expect(appendEntry([u, a], 2, 0, "x")).toBeNull();
});
it("notifies on finish, failure and questions only", () => {
expect(attentionChange("running", "ready")).toBe("finished");
expect(attentionChange("running", "failed")).toBe("failed");
expect(attentionChange("running", "limited")).toBe("failed");
expect(attentionChange("running", "needsInput")).toBe("input");
expect(attentionChange("needsInput", "running")).toBeNull();
expect(attentionChange("ready", "archived")).toBeNull();
expect(attentionChange(undefined, "ready")).toBeNull();
});
it("finds subagent cards and keys their conversations apart", () => {
const card: SubagentEntry = {
type: "subagent",
+13
Переглянути файл
@@ -242,3 +242,16 @@ 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;
}
+16 -19
Переглянути файл
@@ -53,6 +53,7 @@ import {
SESSION_KIND,
TOOL_WINDOW,
appendEntry,
attentionChange,
entriesKey,
isBusy,
sessionKey,
@@ -552,17 +553,14 @@ 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);
@@ -635,28 +633,27 @@ function onEvent(e: AgentEvent) {
}
}
/** 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";
function notifyChange(prev: AgentTask | undefined, task: AgentTask) {
const change = attentionChange(prev?.status, task.status);
if (!change) return;
if (viewing(task.id)) return;
const body =
reason === "input"
change === "input"
? "Waiting for your answer"
: reason === "failed"
? (task?.error ?? "The agent stopped")
: change === "failed"
? (task.error ?? "The agent stopped")
: "Finished";
notifications().notify({
level: reason === "failed" ? "error" : "info",
title,
level: change === "failed" ? "error" : "info",
title: task.title,
body,
key: `agent:${taskId}`,
key: `agent:${task.id}`,
group: "tools",
sticky: reason !== "finished",
sticky: change !== "finished",
actions: [
{
label: reason === "finished" ? "Review" : "Open",
run: () => openTask(taskId),
label: change === "finished" ? "Review" : "Open",
run: () => openTask(task.id),
},
],
});
+2 -15
Переглянути файл
@@ -163,28 +163,16 @@ describe("agent unread activity", () => {
expect([...useAgents.getState().unread]).toEqual(["one"]);
});
it.each([
["finished", "ready"],
["input", "needsInput"],
["failed", "failed"],
["failed", "limited"],
] as const)("marks background attention %s unread", (reason, status) => {
it.each(["ready", "needsInput", "failed", "limited"] as const)("marks background %s transitions unread", (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: "attention", task: "one", eventId: `one:${reason}:2`, reason });
emit({ type: "task", task: task("one", status) });
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) });
@@ -270,7 +258,6 @@ 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 />
-30
Переглянути файл
@@ -1407,33 +1407,3 @@
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;
}
+2 -4
Переглянути файл
@@ -254,8 +254,7 @@ function setSubmittingResult(result: DbQueryResult, on: boolean) {
notifyResults();
}
/** 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 }) {
function Result({ tab }: { tab: ResultTab }) {
const [view, setView] = useState<"table" | "chart">("table");
const [panel, setPanel] = useState<DataPanel | null>(null);
const [searchOpen, setSearchOpen] = useState(false);
@@ -517,7 +516,7 @@ export function Result({ tab, onClose }: { tab: ResultTab; onClose?: () => void
disabled={busy}
onClick={() => void rerunResult(tab.id)}
/>
{!onClose && <PinButton tab={tab} />}
<PinButton tab={tab} />
{view === "table" && (
<IconButton
icon="search"
@@ -569,7 +568,6 @@ export function Result({ tab, onClose }: { tab: ResultTab; onClose?: () => void
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}>
-37
Переглянути файл
@@ -1,37 +0,0 @@
.page {
display: flex;
flex-direction: column;
gap: var(--space-2);
color: var(--fg);
font-size: var(--fs-ui);
}
.intro,
.hint {
margin: 0;
color: var(--fg-muted);
}
.list {
display: flex;
flex-direction: column;
border: 1px solid var(--border-strong);
border-radius: var(--radius-small);
padding: var(--space-0-5) 0;
}
.head,
.row {
display: grid;
grid-template-columns: minmax(160px, 2fr) minmax(140px, 1.5fr) minmax(100px, 1fr) 24px;
align-items: center;
gap: var(--space-2);
min-height: 30px;
padding: 0 var(--space-2);
}
.head {
min-height: 24px;
color: var(--fg-muted);
border-bottom: 1px solid var(--border);
}
.project {
padding-left: var(--space-1);
font-weight: 600;
}
-144
Переглянути файл
@@ -1,144 +0,0 @@
/**
* 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>
);
}
+8 -233
Переглянути файл
@@ -39,14 +39,13 @@ import {
type Panel,
type Tooltip,
} from "@codemirror/view";
import { useEffect, useMemo, useRef, useState, type PointerEvent } from "react";
import { useEffect, useMemo, useState } 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, lazyComponent } from "@/ui";
import { useProject } from "@/platform/project";
import { IconButton, Select } from "@/ui";
import { activeSchema, schemaSwitchable, sourceLabel, splitTarget, targetOf } from "./model";
import { loadSavedCatalog, offerIntrospection } from "./introspection";
import { analyze, templateContexts, valuesSlot } from "./sql/analyze";
@@ -57,14 +56,11 @@ import {
type SqlCandidate,
type SqlCatalog,
} from "./sql/complete";
import { WHOLE_FILE, sqlSupport, type SqlText } from "./sqlSupport";
import { sqlSupport } from "./sqlSupport";
import { snowflakeLanguage } from "./sql/snowflakeHighlight";
import {
bindConsole,
cancelConsole,
closeInlineResults,
inEditorResults,
setInEditorResults,
consoleSchema,
consoleSource,
executeConsole,
@@ -88,7 +84,6 @@ 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";
@@ -257,213 +252,6 @@ 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);
@@ -473,9 +261,6 @@ 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";
@@ -563,12 +348,6 @@ 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"
@@ -729,7 +508,7 @@ function docNode(text: string): Node {
return pre;
}
function applyCandidate(c: SqlCandidate, driver: DbDriver, sql: SqlText) {
function applyCandidate(c: SqlCandidate, driver: DbDriver) {
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;
@@ -752,7 +531,7 @@ function applyCandidate(c: SqlCandidate, driver: DbDriver, sql: SqlText) {
}
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(sql.text(view.state), to, driver);
const a = analyze(view.state.doc.toString(), to, driver);
if (a.fromInsert !== null) {
const clause = ` ${a.lowerKeywords ? "from" : "FROM"} ${c.addFrom}`;
if (a.fromInsert <= to) changes[0]!.insert += clause;
@@ -853,10 +632,8 @@ async function loadQualified(id: string, qualifier: readonly string[]): Promise<
if (schema && !useDatabase.getState().tables[tablesKey(target, schema)]) await loadTables(target, schema);
}
/** 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 {
function completionSource(path: string): 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);
@@ -869,7 +646,7 @@ export function completionSource(path: string, sql: SqlText = WHOLE_FILE): Compl
// 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 = sql.text(ctx.state);
const doc = ctx.state.doc.toString();
const analysis = placeholder
? analyze(doc.slice(0, sel.from) + doc.slice(sel.to), sel.from, driver)
: analyze(doc, ctx.pos, driver);
@@ -897,7 +674,7 @@ export function completionSource(path: string, sql: SqlText = WHOLE_FILE): Compl
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, sql),
apply: applyCandidate(c, driver),
})),
validFor: /^[\p{L}\p{N}_$]*$/u,
};
@@ -1002,8 +779,6 @@ export function consoleExtension(ctx: EditorDocContext): Extension {
consolePath.of(ctx.path),
runField,
runGutter,
inlineField,
syncInline,
showPanel.of(consolePanel(ctx.path)),
EditorState.languageData.of(() => [
{ openideaCompletion: completionSource(ctx.path), [TEMPLATE_CONTEXT_KEY]: templateContextsAt(ctx.path) },
-136
Переглянути файл
@@ -1,136 +0,0 @@
import { act } from "@testing-library/react";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { useProject } from "@/platform/project";
import { consoleExtension } from "./console";
import { SQL_LANGUAGE } from "./sqlLanguage";
import { executeConsole, rerunResult, useDatabase } from "./store";
const backend = vi.hoisted(() => ({ execute: vi.fn(), statements: vi.fn() }));
vi.mock("@/platform/ipc", async (importOriginal) => {
const actual = await importOriginal<typeof import("@/platform/ipc")>();
return {
...actual,
commands: { ...actual.commands, dbExecute: backend.execute, dbStatements: backend.statements },
};
});
vi.mock("@tanstack/react-virtual", () => ({
useVirtualizer: ({ count }: { count: number }) => ({
getTotalSize: () => count * 24,
getVirtualItems: () => Array.from({ length: count }, (_, index) => ({ index, start: index * 24, key: index })),
scrollToIndex: () => {},
}),
}));
const PATH = "/p/console.sql";
const initial = useDatabase.getState();
let runs = 0;
beforeEach(() => {
runs = 0;
useProject.setState({
project: { name: "p", root: "/p", trusted: true } as never,
settings: { database: { inEditorResults: true } } as never,
});
useDatabase.setState({
...initial,
loaded: true,
sources: [{ id: "pg", name: "Local", driver: "postgres", readOnly: false }],
completion: { pg: { defaultSchema: "public", tables: [], foreignKeys: [] } },
consoles: { [PATH]: "pg" },
results: [],
inline: [],
});
backend.statements.mockImplementation((_id: unknown, text: string, from: number, to: number) => {
let at = 0;
const all = text.split(";").flatMap((part) => {
const start = at + part.length - part.trimStart().length;
at += part.length + 1;
const st = part.trim();
return st ? [{ from: start, to: start + st.length, text: st }] : [];
});
const picked = from === to ? all.filter((s) => s.from <= from && from <= s.to + 1) : all;
return Promise.resolve({ status: "ok", data: picked });
});
backend.execute.mockImplementation((_r: unknown, _id: unknown, statements: Array<{ text: string }>) => {
runs++;
return Promise.resolve({
status: "ok",
data: statements.map((st) => ({
statement: st,
result: {
statement: st.text,
columns: [{ name: "v", typeName: "text" }],
rows: [[`${st.text} #${runs}`]],
affected: null,
hasMore: false,
elapsedMs: 1,
executionMs: 1,
},
error: null,
})),
});
});
});
afterEach(() => {
document.body.innerHTML = "";
});
describe("In-Editor Results", () => {
it("keeps a run's result sets out of the result tabs, and re-runs them in place", async () => {
await executeConsole(PATH, "SELECT 1; SELECT 2", 0, 18);
const st = useDatabase.getState();
expect(st.results).toEqual([]);
expect(st.inline.map((r) => r.outcome.statement.text)).toEqual(["SELECT 1", "SELECT 2"]);
const id = st.inline[0]!.id;
await rerunResult(id);
expect(useDatabase.getState().inline[0]!.outcome.result!.rows).toEqual([["SELECT 1 #2"]]);
expect(useDatabase.getState().inline[0]!.id).toBe(id);
});
it("goes to the result tabs while the setting is off", async () => {
useProject.setState({ settings: {} as never });
await executeConsole(PATH, "SELECT 1", 0, 0);
expect(useDatabase.getState().inline).toEqual([]);
expect(useDatabase.getState().results).toHaveLength(1);
});
it("shows each result under its statement, replaces it on a re-run and drops it with the statement", async () => {
const parent = document.createElement("div");
document.body.append(parent);
const doc = "SELECT 1;\nSELECT 2;\n";
const view = new EditorView({
parent,
state: EditorState.create({
doc,
extensions: consoleExtension({ language: SQL_LANGUAGE, path: PATH } as never),
}),
});
const widgets = () => [...view.dom.querySelectorAll(".cm-openidea-db-inline")];
const ids = () => useDatabase.getState().inline.map((r) => r.id);
await act(async () => void (await executeConsole(PATH, view.state.doc.toString(), 0, doc.length)));
await act(async () => {});
expect(widgets()).toHaveLength(2);
const [first, second] = ids();
// Running the first statement again replaces only its own result.
await act(async () => void (await executeConsole(PATH, view.state.doc.toString(), 0, 0)));
await act(async () => {});
expect(ids()).toHaveLength(2);
expect(ids()).toContain(second);
expect(ids()).not.toContain(first);
expect(widgets()).toHaveLength(2);
// Deleting the second statement closes its result.
await act(async () => view.dispatch({ changes: { from: 10, to: 19 } }));
await act(async () => {});
expect(ids()).not.toContain(second);
expect(widgets()).toHaveLength(1);
view.destroy();
});
});
-23
Переглянути файл
@@ -39,8 +39,6 @@ import {
RESULTS_VIEW,
consoleSource,
consoleTints,
inEditorResults,
setInEditorResults,
loadSources,
connect,
loadSchemas,
@@ -81,8 +79,6 @@ function tableTarget(arg: unknown): TableCommandTarget {
return { rows: activeCellGrid()?.selectedRows() ?? [], editor: null };
}
export { activateSettingsPages } from "./settingsPages";
export function activate(): () => void {
const disposers = [
onIdeEvent("dbSourcesChanged", () => {
@@ -124,14 +120,6 @@ 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;
@@ -147,7 +135,6 @@ export function activate(): () => void {
objects: {},
completion: {},
results: [],
inline: [],
output: [],
activeResult: null,
selectedSource: null,
@@ -275,16 +262,6 @@ export function activate(): () => void {
await (await import("./console")).executeInView(e.view, e.ctx.path);
},
},
{
id: "db.toggleInEditorResults",
title: "In-Editor Results",
description: "Show query results in the editor, under the statements that produced them",
category: "Tools",
icon: "db-in-editor-results",
keywords: ["inline", "results", "console", "grid"],
toggled: () => inEditorResults(),
run: () => setInEditorResults(!inEditorResults()),
},
{
id: "db.executeScript",
title: "Execute SQL Script",
-112
Переглянути файл
@@ -1,112 +0,0 @@
import { CompletionContext, type CompletionResult, type CompletionSource } from "@codemirror/autocomplete";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { CONTRIBUTED_HOVER, type ContributedHover } from "@/editor/api";
import { useProject } from "@/platform/project";
import { mapperExtension } from "./mybatis";
import { useDatabase } from "./store";
const published = vi.hoisted(() => new Map<string, Array<{ message: string }>>());
vi.mock("@/editor/lsp/diagnostics", () => ({
setFileDiagnostics: (path: string, _source: string, items: Array<{ message: string }>) => published.set(path, items),
}));
const PATH = "/p/src/main/resources/mapper/UserMapper.xml";
const DOC = `<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.UserMapper">
<select id="find">
select id, nam from users where id = #{id}
</select>
<select id="other">select * from orders</select>
</mapper>
`;
let view: EditorView | null = null;
beforeEach(() => {
vi.useFakeTimers();
published.clear();
useProject.setState({
project: { name: "p", root: "/p", trusted: true } as never,
settings: {
database: { resolutionScopes: [{ path: "src/main/resources/mapper", dataSource: "pg", schema: "" }] },
} as never,
});
const column = (name: string) => ({
name,
dataType: "text",
nullable: true,
primaryKey: name === "id",
hasDefault: false,
});
useDatabase.setState({
loaded: true,
sources: [
{ id: "pg", name: "Local", driver: "postgres" },
{ id: "other", name: "Other", driver: "postgres" },
],
consoles: {},
consoleSchemas: {},
completion: {
pg: {
defaultSchema: "public",
tables: [{ schema: "public", name: "users", kind: "table", columns: [column("id"), column("name")] }],
foreignKeys: [],
},
},
});
});
afterEach(() => {
view?.destroy();
view = null;
vi.useRealTimers();
});
function open(doc: string) {
view = new EditorView({
parent: document.body,
state: EditorState.create({ doc, extensions: mapperExtension({ path: PATH, language: "xml" } as never) }),
});
return view;
}
function completionAt(state: EditorState, pos: number): Promise<CompletionResult | null> {
const sources = state.languageDataAt<CompletionSource>("openideaCompletion", pos);
return Promise.resolve(sources[0]!(new CompletionContext(state, pos, true)));
}
describe("SQL in MyBatis mappers", () => {
it("reports unresolved names of the statements against the scope's data source", () => {
open(DOC);
vi.advanceTimersByTime(1000);
const messages = (published.get(PATH) ?? []).map((d) => d.message);
expect(messages.some((m) => /nam\b/.test(m))).toBe(true);
expect(messages.some((m) => /orders/.test(m))).toBe(true);
expect(messages.some((m) => /users|\bid\b/.test(m))).toBe(false);
});
it("documents tables in the statements and nothing in the XML around them", () => {
const v = open(DOC);
const hover = v.state.languageDataAt<ContributedHover>(CONTRIBUTED_HOVER, 0)[0]!;
expect(hover(v.state, DOC.indexOf("users") + 2)?.markdown).toMatch(/users/);
expect(hover(v.state, DOC.indexOf("namespace") + 2)).toBeNull();
});
it("completes columns inside a statement only", async () => {
const doc = DOC.replace("select id, nam from users", "select n from users");
const v = open(doc);
const result = await completionAt(v.state, doc.indexOf("select n") + "select n".length);
expect(result?.options.map((o) => o.label)).toContain("name");
expect(await completionAt(v.state, doc.indexOf("namespace") + 4)).toBeNull();
});
it("leaves other XML files alone", () => {
const v = open("<beans><select>not sql</select></beans>");
vi.advanceTimersByTime(1000);
expect(published.get(PATH) ?? []).toEqual([]);
expect(v.dom.querySelectorAll("[class*=ͼ]").length).toBe(0);
});
});
-123
Переглянути файл
@@ -1,123 +0,0 @@
/**
* SQL in MyBatis mapper XML: the statements of `<select>`, `<insert>`, `<update>`, `<delete>`
* and `<sql>` are highlighted as SQL and get the SQL file's tools — completion, inspections,
* Go to Declaration and Quick Documentation — against the file's data source (its SQL
* resolution scope, or the project's only data source). See `sql/mapper` for what is SQL.
*/
import { MSSQL, MySQL, PLSQL, PostgreSQL, SQLite, StandardSQL, type SQLDialect } from "@codemirror/lang-sql";
import { highlightingFor } from "@codemirror/language";
import { EditorState, RangeSetBuilder, StateEffect, type Extension, type Text } from "@codemirror/state";
import { Decoration, ViewPlugin, type DecorationSet, type EditorView, type ViewUpdate } from "@codemirror/view";
import { highlightTree } from "@lezer/highlight";
import type { EditorDocContext } from "@/editor/api";
import type { DbDriver } from "@/platform/ipc";
import { completionSource } from "./console";
import { inMapperSql, isMapper, mapperSql, type MapperSql } from "./sql/mapper";
import { sqlSupport, type SqlText } from "./sqlSupport";
import { consoleSource, sourceById, useDatabase } from "./store";
const cache = new WeakMap<Text, MapperSql | null>();
/** The file's data source (and so its dialect) changed: colour the statements again. */
const recolour = StateEffect.define<null>();
/** The SQL of the mapper in `doc` (null when it is no mapper), computed once per document version. */
function mapperOf(doc: Text): MapperSql | null {
let sql = cache.get(doc);
if (sql === undefined) {
const text = doc.toString();
sql = isMapper(text) ? mapperSql(text) : null;
cache.set(doc, sql);
}
return sql;
}
const MAPPER_SQL: SqlText = {
text: (state) => mapperOf(state.doc)?.text ?? " ".repeat(state.doc.length),
at: (state, pos) => {
const sql = mapperOf(state.doc);
return !!sql && inMapperSql(sql, pos);
},
};
function dialectOf(driver: DbDriver): SQLDialect {
switch (driver) {
case "postgres":
return PostgreSQL;
case "mysql":
return MySQL;
case "sqlite":
return SQLite;
case "sqlServer":
return MSSQL;
case "oracle":
return PLSQL;
default:
return StandardSQL;
}
}
/** Syntax colours of the statements, in the bound data source's dialect, over the XML colours. */
function sqlColours(path: string): Extension {
const build = (view: EditorView): DecorationSet => {
const sql = mapperOf(view.state.doc);
if (!sql?.segments.length) return Decoration.none;
const driver = sourceById(consoleSource(path))?.driver ?? "sqlite";
const tree = dialectOf(driver).language.parser.parse(sql.text);
const builder = new RangeSetBuilder<Decoration>();
const marks = new Map<string, Decoration>();
const style = { style: (tags: Parameters<typeof highlightingFor>[1]) => highlightingFor(view.state, tags) };
let segment = 0;
for (const { from, to } of view.visibleRanges)
highlightTree(
tree,
style,
(a, b, cls) => {
// Only the file's own SQL text: the words standing in for tags are not shown.
while (segment < sql.segments.length && sql.segments[segment]!.to <= a) segment++;
for (let i = segment; i < sql.segments.length && sql.segments[i]!.from < b; i++) {
const s = sql.segments[i]!;
const f = Math.max(a, s.from);
const t = Math.min(b, s.to);
if (f >= t) continue;
let mark = marks.get(cls);
if (!mark) marks.set(cls, (mark = Decoration.mark({ class: cls })));
builder.add(f, t, mark);
}
},
from,
to,
);
return builder.finish();
};
return ViewPlugin.fromClass(
class {
decorations: DecorationSet;
private stop: () => void;
constructor(readonly view: EditorView) {
this.decorations = build(view);
// Another data source may mean another dialect.
this.stop = useDatabase.subscribe((s, prev) => {
if (s.sources !== prev.sources || s.consoles !== prev.consoles)
queueMicrotask(() => view.dispatch({ effects: recolour.of(null) }));
});
}
update(u: ViewUpdate) {
if (u.docChanged || u.viewportChanged || u.transactions.some((tr) => tr.effects.some((e) => e.is(recolour))))
this.decorations = build(u.view);
}
destroy() {
this.stop();
}
},
{ decorations: (v) => v.decorations },
);
}
/** The SQL support of MyBatis mapper `ctx.path` (inert in other XML files). */
export function mapperExtension(ctx: EditorDocContext): Extension {
return [
sqlColours(ctx.path),
EditorState.languageData.of(() => [{ openideaCompletion: completionSource(ctx.path, MAPPER_SQL) }]),
sqlSupport(ctx.path, MAPPER_SQL),
];
}
-54
Переглянути файл
@@ -1,54 +0,0 @@
import { beforeEach, describe, expect, it } from "vitest";
import { useProject } from "@/platform/project";
import { resolutionScopeOf, validateResolutionScopes } from "./resolutionScopes";
import { bindConsole, consoleSchema, consoleSource, useDatabase } from "./store";
const scopes = validateResolutionScopes([
{ path: "", dataSource: "main", schema: "" },
{ path: "./src/main/resources/mapper/", dataSource: "orders", schema: "sales" },
{ path: "src/main/resources/mapper/legacy/Old.xml", dataSource: "legacy", schema: "" },
{ path: "src/gone", dataSource: "removed", schema: "" },
]);
describe("SQL resolution scopes", () => {
it("normalises paths and picks the deepest folder or file covering a file, else the project row", () => {
expect(scopes[1]!.path).toBe("src/main/resources/mapper");
const at = (rel: string) => resolutionScopeOf(`/p/${rel}`, "/p", scopes)?.dataSource;
expect(at("src/main/resources/mapper/UserMapper.xml")).toBe("orders");
expect(at("src/main/resources/mapper/legacy/Old.xml")).toBe("legacy");
expect(at("src/main/resources/mapper/legacy/New.xml")).toBe("orders");
// A sibling folder whose name starts the same is not inside.
expect(at("src/main/resources/mapperx/A.xml")).toBe("main");
expect(resolutionScopeOf("/elsewhere/a.sql", "/p", scopes)).toBeNull();
});
it("skips rows whose data source no longer exists", () => {
const known = (id: string) => id !== "removed";
expect(resolutionScopeOf("/p/src/gone/a.sql", "/p", scopes, known)?.dataSource).toBe("main");
});
});
describe("the data source a SQL file resolves against", () => {
beforeEach(() => {
useProject.setState({
project: { name: "p", root: "/p", trusted: true } as never,
settings: { database: { resolutionScopes: scopes } } as never,
});
useDatabase.setState({
sources: ["main", "orders", "legacy"].map((id) => ({ id, name: id, driver: "postgres" as const })),
consoles: {},
consoleSchemas: {},
completion: { orders: { defaultSchema: "public", tables: [], foreignKeys: [] } },
});
});
it("is the one picked in its toolbar, else its scope's (with the scope's schema)", () => {
const file = "/p/src/main/resources/mapper/UserMapper.xml";
expect(consoleSource(file)).toBe("orders");
expect(consoleSchema(file)).toBe("sales");
bindConsole(file, "legacy");
expect(consoleSource(file)).toBe("legacy");
bindConsole(file, null);
expect(consoleSource("/p/scratch.sql")).toBe("main");
});
});
-61
Переглянути файл
@@ -1,61 +0,0 @@
/**
* 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;
}
-16
Переглянути файл
@@ -1,16 +0,0 @@
import { lazyComponent } from "@/ui";
import { registerSettingsPage } from "@/workbench/contributions";
/** Settings › Languages & Frameworks › SQL Resolution Scopes (also used by the Settings window). */
export function activateSettingsPages(): () => void {
return registerSettingsPage({
id: "languages.sqlResolutionScopes",
title: "SQL Resolution Scopes",
group: "Languages & Frameworks",
order: 404.5,
projectScope: true,
defaultScope: "project",
keywords: ["sql", "data source", "database", "schema", "mybatis", "mapper", "resolve", "dialect"],
component: lazyComponent(() => import("./SqlScopesPage").then((m) => m.SqlScopesPage)),
});
}
-55
Переглянути файл
@@ -1,55 +0,0 @@
import { describe, expect, it } from "vitest";
import { inMapperSql, isMapper, mapperSql } from "./mapper";
const MAPPER = `<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.UserMapper">
<resultMap id="user" type="User"><id column="id" property="id"/></resultMap>
<select id="find" resultMap="user">
select id, name from users
<where>
<if test="name != null">and name = #{name}</if>
<if test="ids != null">and id in
<foreach collection="ids" item="i" open="(" separator="," close=")">#{i}</foreach>
</if>
and age &gt; 18
</where>
</select>
<insert id="add">
<selectKey keyProperty="id" resultType="int">select last_insert_id()</selectKey>
insert into users (name) values (#{name})
</insert>
<!-- <select id="old">select * from old</select> -->
<update id="rename"><![CDATA[update users set name = #{name} where age < 3]]></update>
<update id="touch">update users <set><if test="a">name = #{a},</if></set> where id = #{id}</update>
</mapper>`;
describe("MyBatis mapper SQL", () => {
it("recognises mapper files", () => {
expect(isMapper(MAPPER)).toBe(true);
expect(isMapper("<beans><bean id='a'/></beans>")).toBe(false);
});
it("keeps the statements' SQL at its offsets and blanks the rest", () => {
const { text } = mapperSql(MAPPER);
expect(text).toHaveLength(MAPPER.length);
expect(text.split("\n")).toHaveLength(MAPPER.split("\n").length);
const sql = text.replace(/\s+/g, " ").trim();
expect(sql).toBe(
"select id, name from users where name = ? and id in ( ? ) and age > 18 ; " +
"insert into users (name) values (? ) ; update users set name = ? where age < 3 ; " +
"update users set name = ? where id = ? ;",
);
const at = MAPPER.indexOf("users");
expect(text.slice(at, at + 5)).toBe("users");
});
it("knows which offsets are SQL", () => {
const sql = mapperSql(MAPPER);
expect(inMapperSql(sql, MAPPER.indexOf("from users") + 2)).toBe(true);
expect(inMapperSql(sql, MAPPER.indexOf("resultMap="))).toBe(false);
expect(inMapperSql(sql, MAPPER.indexOf('test="name'))).toBe(false);
expect(inMapperSql(sql, MAPPER.indexOf("last_insert_id"))).toBe(false);
expect(inMapperSql(sql, MAPPER.indexOf("from old"))).toBe(false);
});
});
-154
Переглянути файл
@@ -1,154 +0,0 @@
/**
* 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);
}
+14 -41
Переглянути файл
@@ -20,7 +20,6 @@ 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). */
@@ -39,29 +38,18 @@ function sourceOf(path: string): { id: string | null; driver: DbDriver; model: D
};
}
/**
* 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 {
function resolver(path: string, state: EditorState): SqlResolver {
const { driver, model } = sourceOf(path);
return new SqlResolver(sql.text(state), driver, model);
return new SqlResolver(state.doc.toString(), driver, model);
}
/** Unresolved tables / columns / aliases as error diagnostics, re-checked after edits and schema loads. */
function inspections(path: string, sql: SqlText): Extension {
function inspections(path: string): 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, sql).problems() : [];
const problems = sourceOf(path).model ? resolver(path, view.state).problems() : [];
setFileDiagnostics(
path,
INSPECTIONS,
@@ -81,18 +69,9 @@ function inspections(path: string, sql: SqlText): 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 ||
s.sources !== prev.sources
)
if (s.completion !== prev.completion || s.consoles !== prev.consoles || s.consoleSchemas !== prev.consoleSchemas)
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();
@@ -100,20 +79,16 @@ function inspections(path: string, sql: SqlText): Extension {
destroy: () => {
clearTimeout(timer);
unsubscribe();
unsubscribeSettings();
setFileDiagnostics(path, INSPECTIONS, []);
},
};
});
}
function definition(path: string, sql: SqlText): ContributedDefinition {
function definition(path: string): ContributedDefinition {
return (view, pos) => {
if (sql.at && !sql.at(view.state, pos)) return false;
const r = resolver(path, view.state, sql).resolveAt(pos);
const r = resolver(path, view.state).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);
@@ -197,10 +172,9 @@ function symbolDoc(sym: SqlSymbol, model: DbCompletion | null): string | null {
}
}
function hover(path: string, sql: SqlText): ContributedHover {
function hover(path: string): ContributedHover {
return (state, pos) => {
if (sql.at && !sql.at(state, pos)) return null;
const r = resolver(path, state, sql).resolveAt(pos);
const r = resolver(path, state).resolveAt(pos);
const markdown = r?.symbol ? symbolDoc(r.symbol, sourceOf(path).model) : null;
return r && markdown ? { from: r.from, to: r.to, markdown } : null;
};
@@ -210,12 +184,11 @@ function formatter(path: string): ContributedFormatter {
return (state, range) => formatSql(state.doc.toString(), sourceOf(path).driver, range);
}
/** 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 {
export function sqlSupport(path: string): Extension {
const data = {
[CONTRIBUTED_DEFINITION]: definition(path, sql),
[CONTRIBUTED_HOVER]: hover(path, sql),
...(sql === WHOLE_FILE ? { [CONTRIBUTED_FORMAT]: formatter(path) } : {}),
[CONTRIBUTED_DEFINITION]: definition(path),
[CONTRIBUTED_HOVER]: hover(path),
[CONTRIBUTED_FORMAT]: formatter(path),
};
return [inspections(path, sql), EditorState.languageData.of(() => [data])];
return [inspections(path), EditorState.languageData.of(() => [data])];
}
+6 -58
Переглянути файл
@@ -56,7 +56,6 @@ import { formatted } from "./sql/format";
import { bindParams, findParams } from "./sql/params";
import { isReadOnlyQuery } from "./sql/readOnly";
import { pageFetch } from "./resultView";
import { resolutionScopeOf, resolutionScopesOf, type SqlResolutionScope } from "./resolutionScopes";
import { databaseRequest, invalidateDatabaseRequests, projectRequest } from "./requests";
import { tx } from "@/platform/i18n";
@@ -88,18 +87,6 @@ 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). */
@@ -180,8 +167,6 @@ 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[];
@@ -249,7 +234,6 @@ export const useDatabase = create<DatabaseState>(() => ({
separateProceduresAndFunctions: readSeparateProceduresAndFunctions(),
completion: {},
results: [],
inline: [],
activeResult: null,
output: [],
running: {},
@@ -885,10 +869,7 @@ export function bindConsole(path: string, id: string | null) {
export function consoleSchema(path: string): string {
const s = useDatabase.getState();
const id = consoleSource(path);
// 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);
return activeSchema(s.consoleSchemas[path], id ? s.completion[id]?.defaultSchema : undefined);
}
/** Sets (or clears, for `null`) the console's active schema and remembers it per console file. */
@@ -906,26 +887,11 @@ export function setConsoleSchema(path: string, schema: string | null) {
});
}
/** 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.
*/
/** The data source a console / SQL file runs on: its binding, 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;
}
@@ -1175,10 +1141,6 @@ 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),
@@ -1320,7 +1282,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 = findResult(tabId);
const tab = useDatabase.getState().results.find((r) => r.id === tabId);
if (!tab || tab.busy) return;
if (tab.plan) {
patchResult(tabId, { busy: true });
@@ -1343,16 +1305,8 @@ 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>) {
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) }));
useDatabase.setState((s) => ({ results: s.results.map((r) => (r.id === tabId ? { ...r, ...p } : r)) }));
}
/**
@@ -1361,7 +1315,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 = findResult(tabId);
const tab = useDatabase.getState().results.find((r) => r.id === tabId);
if (!tab || tab.busy || tab.plan) return;
if (page > 0 && !pageable(tab)) return;
patchResult(tabId, { busy: true });
@@ -1409,7 +1363,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 = findResult(tabId);
const tab = useDatabase.getState().results.find((r) => r.id === tabId);
if (!tab || tab.busy || !countable(tab)) return null;
const text = countQuery(tab.outcome.statement.text)!;
patchResult(tabId, { busy: true });
@@ -1514,12 +1468,6 @@ 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 });
}
-9
Переглянути файл
@@ -20,7 +20,6 @@ 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",
@@ -50,14 +49,6 @@ const list = [
];
describe("Attach to Process popup model", () => {
it("attaches the chosen Unity Editor by its exact ID without launching or using a native adapter", async () => {
const launch = await attachConfig(proc({ pid: 1234, kind: "unity", name: "Unity Editor" }), "/game");
expect(launch).toMatchObject({ adapter: "unity", request: "attach", program: null, cwd: "/game" });
expect(JSON.parse(launch.extraJson!)).toEqual({
name: "Unity Editor (1234)",
__exceptionOptions: [],
});
});
it("groups processes by debugger in IDEA's order with counts", () => {
const rows = attachRows(list, "");
expect(rows.filter((r) => r.kind === "group").map((r) => r.kind === "group" && `${r.label}:${r.count}`)).toEqual([
-1
Переглянути файл
@@ -12,7 +12,6 @@ describe("missing debug adapters", () => {
});
it("offers the managed install of a missing adapter binary", () => {
expect(missingAdapter("unity", unavailable("debug adapter `unity` not found"))?.tool).toBe("unity-debug");
const e = unavailable(
"debug adapter `js-debug` not found (`js-debug-adapter` is neither installed by OpenIDEA nor on PATH)",
);
-142
Переглянути файл
@@ -1,142 +0,0 @@
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);
});
+23 -11
Переглянути файл
@@ -80,9 +80,14 @@ 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 } from "./ui/popoverStore";
import {
openBreakpointsDialog,
openConfigChooser,
openEvaluateDialog,
openSmartStepChooser,
useOverlays,
} 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;
@@ -175,6 +180,22 @@ 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;
@@ -870,15 +891,6 @@ 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",
+1 -10
Переглянути файл
@@ -7,7 +7,6 @@ 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)",
@@ -16,7 +15,7 @@ export const KIND_LABELS: Record<AttachKind, string> = {
native: "Native (LLDB)",
};
const KIND_ORDER: AttachKind[] = ["unity", "java", "node", "python", "dotnet", "go", "native"];
const KIND_ORDER: AttachKind[] = ["java", "node", "python", "dotnet", "go", "native"];
export type AttachRow =
| { kind: "group"; key: string; label: string; count: number }
@@ -65,14 +64,6 @@ function base(p: AttachableProcess, cwd: string, extra: Record<string, unknown>)
export async function attachConfig(p: AttachableProcess, root: string): Promise<LaunchConfig> {
const skip = workflowSettings().debugger.skipLibraryCode;
switch (p.kind) {
case "unity":
return {
...base(p, root, {
name: `Unity Editor (${p.pid})`,
__exceptionOptions: [],
}),
adapter: "unity",
};
case "java":
return javaAttachConfig(
{ name: `${p.name} (${p.pid})`, module: "", hostName: p.host ?? "localhost", port: p.port! },
-44
Переглянути файл
@@ -1,44 +0,0 @@
import { executeAction } from "@/platform/actions";
import { call, commands, isTauri, type RunConfig } from "@/platform/ipc";
import { useProject } from "@/platform/project";
import { notifications } from "@/workbench/contributions";
import { missingAdapter } from "./missingAdapter";
import { useOverlays } from "./ui/popoverStore";
/** Applies only the latest request of the open popup; results for a closed or refreshed one are dropped. */
export async function openAttachPopup(mode: "all" | "unity" = "all", runConfig?: RunConfig) {
if (!isTauri()) {
notifications().notify({ group: "run", level: "warning", title: "Attaching needs the desktop app" });
return;
}
const projectRoot = useProject.getState().project?.root ?? null;
const pending = { processes: null, error: null, mode, projectRoot, runConfig };
useOverlays.setState({ attach: pending });
const current = () =>
useOverlays.getState().attach === pending && (useProject.getState().project?.root ?? null) === projectRoot;
try {
const processes = await call(
mode === "unity" ? commands.debugUnityProcesses() : commands.debugAttachableProcesses(),
);
if (current()) useOverlays.setState({ attach: { ...pending, processes } });
} catch (e) {
if (current())
useOverlays.setState({
attach: {
...pending,
processes: [],
error: e instanceof Error ? e.message : String(e),
installTool: mode === "unity" ? missingAdapter("unity", e)?.tool : undefined,
},
});
}
}
export async function installAttachAdapter() {
const state = useOverlays.getState().attach;
if (!state?.installTool) return;
await executeAction("tools.install", state.installTool);
if (useOverlays.getState().attach === state && useProject.getState().project?.root === state.projectRoot) {
await openAttachPopup(state.mode, state.runConfig);
}
}
-1
Переглянути файл
@@ -145,7 +145,6 @@ export function activate(): () => void {
useProject.subscribe((s, prev) => {
const root = s.project?.root ?? null;
if (root !== (prev.project?.root ?? null) || s.project?.trusted !== prev.project?.trusted) {
useOverlays.setState({ attach: null });
resetSessions();
loadWatches(root);
loadBreakpoints(root);
-1
Переглянути файл
@@ -8,7 +8,6 @@ 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" },
+4 -60
Переглянути файл
@@ -33,7 +33,6 @@ import {
type SpecialBreakpoint,
} from "../breakpoints/special";
import { attachConfig, attachDetail, attachRows, type AttachRow } from "../attach";
import { openAttachPopup, installAttachAdapter } from "../attachPopup";
import {
exceptionGroups,
filterHint,
@@ -916,7 +915,6 @@ 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;
@@ -927,11 +925,10 @@ 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, runConfig: state.runConfig });
await startSession(await attachConfig(p, root), { rerunnable: false });
} catch (e) {
notifications().notify({
group: "run",
@@ -951,44 +948,8 @@ function AttachPopup() {
}
};
return (
<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);
},
},
]}
>
<Dialog open onClose={close} title="Attach to Process" width={640} position="top" aria-label="Attach to 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) => {
@@ -1014,20 +975,7 @@ function AttachPopup() {
<T>Loading processes…</T>
</div>
) : state.error ? (
<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>
<div className={styles.empty}>{state.error}</div>
) : (
<List<AttachRow>
items={rows}
@@ -1048,11 +996,7 @@ function AttachPopup() {
className={styles.attachList}
empty={
<div className={styles.empty}>
{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.`}
{filter ? tx`No attachable processes match the filter.` : tx`No attachable processes.`}
</div>
}
renderItem={(r) =>
+1 -8
Переглянути файл
@@ -15,14 +15,7 @@ interface OverlayState {
breakpoints: { path?: string; id?: string } | null;
chooser: { configs: RunConfig[] } | null;
/** Attach to Process popup; `processes` is null while loading. */
attach: {
processes: AttachableProcess[] | null;
error: string | null;
mode?: "all" | "unity";
projectRoot?: string | null;
installTool?: string;
runConfig?: RunConfig;
} | null;
attach: { processes: AttachableProcess[] | null; error: string | null } | null;
/**
* Smart Step Into: picked in the editor when `inline` is set (targets sorted
* by position, `index` the selected one), else in the chooser dialog.
+1 -2
Переглянути файл
@@ -48,7 +48,7 @@ import { activate as analysis } from "./analysis";
import { activate as services } from "./services";
import { activate as github, activateSettingsPages as githubPages } from "./github";
import { activate as httpClient } from "./http-client";
import { activate as database, activateSettingsPages as databasePages } from "./database";
import { activate as database } from "./database";
import { activate as graphql } from "./graphql";
import { activate as deployment, activateDeploymentWindow } from "./deployment";
import { activate as agents, activateSettingsPages as agentsPages } from "./agents";
@@ -188,7 +188,6 @@ export function activateSettingsWindowFeatures(parent: string): () => void {
["vim", vimPages],
["vcs", vcsPages],
["github", githubPages],
["database", databasePages],
];
return activateAll("settings pages", pages);
}
+2 -46
Переглянути файл
@@ -1,8 +1,8 @@
import { afterEach, beforeEach, expect, it, vi } from "vitest";
import { act, cleanup, fireEvent, render, screen } from "@testing-library/react";
import { executeAction, executeActionFrom, getAction, isActionEnabled, registerAction } from "@/platform/actions";
import { executeAction, executeActionFrom, getAction, registerAction } from "@/platform/actions";
import { setContext } from "@/platform/context";
import type { ProjectInfo, RunConfig } from "@/platform/ipc";
import type { RunConfig } from "@/platform/ipc";
import {
registerMenuGroup,
registerRunConfigType,
@@ -10,7 +10,6 @@ import {
type DebugRunSession,
} from "@/workbench/contributions";
import { useContextMenuStore } from "@/ui";
import { useProject } from "@/platform/project";
import { applicationConfig } from "./application";
import { activate } from "./index";
import { RunWidget } from "./RunWidget";
@@ -53,7 +52,6 @@ const debug = (c: RunConfig, startedAt = 2): DebugRunSession => ({
});
let dispose: () => void;
beforeEach(() => {
useProject.setState({ project: null });
resetRuns();
useRun.setState({ configs: [app, npm], selectedId: app.id, loaded: true });
useDebugRunSessions.setState({ sessions: [] });
@@ -63,51 +61,9 @@ beforeEach(() => {
afterEach(() => {
cleanup();
dispose();
useProject.setState({ project: null });
useDebugRunSessions.setState({ sessions: [] });
});
function openUnity() {
useProject.setState({
project: {
root: "/game",
name: "Game",
trusted: true,
isGit: false,
settings: {} as ProjectInfo["settings"],
unity: { editorVersion: "6000.0.1f1", projects: [], solutions: [] },
},
});
}
it("keeps other configurations available in a Unity project", () => {
openUnity();
useRun.setState({ configs: [app, npm], selectedId: app.id, loaded: true });
render(<RunWidget />);
expect(screen.getByRole("button", { name: `Run '${app.name}'` })).toBeEnabled();
expect(isActionEnabled(getAction("run.run")!)).toBe(true);
expect(isActionEnabled(getAction("run.chooseConfig")!)).toBe(true);
});
it("attaches when the Unity configuration is debugged", async () => {
openUnity();
const unity = { ...config("unity-editor"), name: "Unity Editor", kind: "unity-editor", command: "" };
useRun.setState({ configs: [unity, app], selectedId: unity.id, loaded: true });
const attach = vi.fn();
const unregister = registerAction({ id: "debug.attachUnity", title: "Attach", run: attach });
try {
render(<RunWidget />);
expect(screen.getByRole("button", { name: `'${unity.name}' can only be debugged` })).toBeDisabled();
await act(async () => {
await executeAction("run.debug");
});
expect(attach).toHaveBeenCalledOnce();
expect(useRun.getState().configs).toContain(app);
} finally {
unregister();
}
});
it("reruns and stops the selected configuration among several running sessions", () => {
useRun.setState({ sessions: [run(app), run(npm, 3)] });
render(<RunWidget />);
-26
Переглянути файл
@@ -67,32 +67,6 @@ it("lists pinned configurations first, in pin order, and not again in their grou
expect(names(buildRows(configs, "s", null, [], ["serve"]))).toEqual(["[Pinned]", "serve", "---", "edit"]);
});
it("adds and selects a Unity attach configuration without hiding other configurations", async () => {
useProject.setState({ project: { root: "/pinned", unity: {} } as never });
await loadConfigs();
expect(useRun.getState().configs.map((c) => c.id)).toEqual(["build", "serve", "App", "unity-editor"]);
expect(useRun.getState().selectedId).toBe("unity-editor");
await loadConfigs();
expect(useRun.getState().configs.filter((c) => c.kind === "unity-editor")).toHaveLength(1);
});
it("keeps a configuration whose id collides with the Unity default", async () => {
useProject.setState({ project: { root: "/pinned", unity: {} } as never });
ipc.runConfigs.mockResolvedValue({ status: "ok", data: [config("unity-editor")] });
await loadConfigs();
expect(useRun.getState().configs.map((c) => c.id)).toEqual(["unity-editor", "unity-editor-attach"]);
expect(useRun.getState().selectedId).toBe("unity-editor-attach");
});
it("retains a saved Unity configuration and selected configuration", async () => {
useProject.setState({ project: { root: "/pinned", unity: {} } as never });
ipc.runConfigs.mockResolvedValue({ status: "ok", data: [...configs, config("my-unity", "unity-editor")] });
useRun.setState({ selectedId: "serve" });
await loadConfigs();
expect(useRun.getState().configs.filter((c) => c.kind === "unity-editor")).toHaveLength(1);
expect(useRun.getState().selectedId).toBe("serve");
});
it("keeps pins per project across reloads", async () => {
await loadConfigs();
togglePinned("serve");
-10
Переглянути файл
@@ -104,7 +104,6 @@ import { TEST_TREE_FOCUS, testTree } from "./testTree";
import { startAgentRun, trimAgentArchive, type AgentRunRequest } from "./agentRuns";
import { compoundTargets, selectedTarget } from "./sessionTargets";
import { tx } from "@/platform/i18n";
import { UNITY_CONFIG_KIND, showUnityAttach } from "./unity";
function trackFailedTestSelection(): () => void {
let signature = "";
@@ -172,7 +171,6 @@ async function debugConfig(config: RunConfig, chain: readonly string[] = [], sho
}
if (remoteDebugBlocked(config)) return;
if (!(await prepareLaunch(config, chain, show))) return;
if (config.kind === UNITY_CONFIG_KIND) return showUnityAttach(config);
// Python on a Docker / Compose target: debugpy in the container, the debugger attaches.
if (containerDebuggable(config) && getAction("debug.attach")) {
await debugInContainer(config);
@@ -490,14 +488,6 @@ export function activate(): () => void {
when: "projectOpen",
run: () => debugSelected(),
},
{
id: "run.attachUnity",
title: "Attach to Unity Process",
category: "Run",
icon: "debug",
when: "projectOpen",
run: () => showUnityAttach(),
},
{
id: "run.runContext",
title: "Run Context Configuration",
+1 -20
Переглянути файл
@@ -65,7 +65,6 @@ import { tomcatBrowserUrl } from "./tomcat";
import { gradleBootLaunch, gradleDelegation, gradleTestLaunch } from "./gradleRun";
import { openUrl } from "./navigate";
import { tx } from "@/platform/i18n";
import { UNITY_CONFIG_KIND } from "./unity";
/** The permanent "Current File" pseudo-configuration of the chooser (runs the active file's context). */
export const CURRENT_FILE = "current-file";
@@ -241,29 +240,11 @@ export async function loadConfigs(): Promise<void> {
const temps = kept.length ? await call(commands.runApplySettings(kept)).catch(() => kept) : kept;
if (useProject.getState().project?.root !== root) return;
const configs = [...saved, ...temps];
if (useProject.getState().project?.unity && !configs.some((config) => config.kind === UNITY_CONFIG_KIND)) {
let id = "unity-editor";
while (configs.some((config) => config.id === id)) id += "-attach";
configs.push({
id,
name: "Unity Editor",
kind: UNITY_CONFIG_KIND,
command: "",
args: [],
cwd: null,
env: {},
detected: true,
isTest: false,
debugAdapter: null,
});
}
const stored = useRun.getState().selectedId ?? readSelected(root);
const selectedId =
stored === CURRENT_FILE || configs.some((c) => c.id === stored)
? stored
: (configs.find((config) => config.kind === UNITY_CONFIG_KIND)?.id ??
defaultSelection(saved)?.id ??
CURRENT_FILE);
: (defaultSelection(saved)?.id ?? CURRENT_FILE);
useRun.setState({
configs,
temporary: temps.map((t) => t.id),
-9
Переглянути файл
@@ -28,7 +28,6 @@ import { dotnetProjectType, dotnetTestType } from "./dotnetTypes";
import { rakeType, rspecType, rubyScriptType } from "./rubyTypes";
import { djangoTestType } from "./djangoTypes";
import { phpunitType } from "./phpunitTypes";
import { UNITY_CONFIG_KIND } from "./unity";
export const COMPOUND = "compound";
@@ -476,14 +475,6 @@ const pytest: RunConfigTypeContribution = {
};
export const BUILTIN_TYPES: readonly RunConfigTypeContribution[] = [
{
id: UNITY_CONFIG_KIND,
label: "Unity Editor",
icon: "attach-to-process",
debugOnly: true,
fields: [],
commandLine: () => null,
},
shell,
program,
npm,
-13
Переглянути файл
@@ -1,13 +0,0 @@
import { executeAction, getAction } from "@/platform/actions";
import type { RunConfig } from "@/platform/ipc";
import { notifications } from "@/workbench/contributions";
export const UNITY_CONFIG_KIND = "unity-editor";
export async function showUnityAttach(config?: RunConfig): Promise<void> {
if (!getAction("debug.attachUnity")) {
notifications().notify({ group: "run", level: "warning", title: "Debugger is not available" });
return;
}
await executeAction("debug.attachUnity", config);
}
-2
Переглянути файл
@@ -156,10 +156,8 @@ describe("appearance & behavior settings", () => {
expect(validateNotifications({ groups: { vcs: { display: "weird", log: false } }, sound: 1 })).toEqual({
balloons: true,
sound: false,
systemNotifications: true,
groups: { vcs: { display: "balloon", log: false } },
});
expect(validateNotifications({ systemNotifications: false }).systemNotifications).toBe(false);
});
});
+2 -3
Переглянути файл
@@ -152,11 +152,10 @@ function PageHost({
const spec = page ? builtinSpec(page.id) : undefined;
const projectScope = !!(spec?.projectScope ?? page?.projectScope) && hasProject && !newProjects;
const scopeKey = spec?.scopeGroup ?? pageId;
const defaultScope = spec?.defaultScope ?? page?.defaultScope;
const chosen = useSettingsDialog((s) => s.scopes[scopeKey]) ?? defaultScope;
const chosen = useSettingsDialog((s) => s.scopes[scopeKey]) ?? spec?.defaultScope;
const scope: Scope = projectScope && chosen === "project" ? "project" : "global";
// Where a project value is the norm, say what the global one is for.
const globalNote = newProjects || (projectScope && scope === "global" && defaultScope === "project");
const globalNote = newProjects || (projectScope && scope === "global" && spec?.defaultScope === "project");
const ctx = useMemo(() => ({ pageId, scope }), [pageId, scope]);
const form = useSettingsFormFor(pageId, scope);
const focus = useSettingsDialog((s) => s.focus);
+1 -9
Переглянути файл
@@ -108,8 +108,6 @@ export interface NotificationGroupValid {
export interface NotificationsValid {
balloons: boolean;
sound: boolean;
/** Mirror balloon notifications to the OS when no OpenIDEA window is focused. */
systemNotifications: boolean;
groups: Record<string, NotificationGroupValid>;
}
@@ -162,12 +160,7 @@ export const DEFAULT_GENERAL_EXTRAS: GeneralExtras = {
dateFormat: { overrideSystem: false, pattern: "dd.MM.yyyy", use24Hour: true, pretty: true },
};
export const DEFAULT_NOTIFICATIONS: NotificationsValid = {
balloons: true,
sound: false,
systemNotifications: true,
groups: {},
};
export const DEFAULT_NOTIFICATIONS: NotificationsValid = { balloons: true, sound: false, groups: {} };
type Obj = Record<string, unknown>;
const obj = (v: unknown): Obj => (v && typeof v === "object" && !Array.isArray(v) ? (v as Obj) : {});
@@ -270,7 +263,6 @@ export function validateNotifications(raw: unknown): NotificationsValid {
return {
balloons: bool(n.balloons, DEFAULT_NOTIFICATIONS.balloons),
sound: bool(n.sound, DEFAULT_NOTIFICATIONS.sound),
systemNotifications: bool(n.systemNotifications, DEFAULT_NOTIFICATIONS.systemNotifications),
groups,
};
}
-14
Переглянути файл
@@ -63,8 +63,6 @@ export interface ValidSettings extends WorkflowSettings {
plugins: Record<string, Record<string, unknown>>;
scopes: NamedScope[];
fileColors: FileColorSettings;
/** Database › Query Execution. */
database: { inEditorResults: boolean; resolutionScopes: Array<{ path: string; dataSource: string; schema: string }> };
general: {
reopenLastProject: boolean;
confirmExit: boolean;
@@ -167,7 +165,6 @@ export const DEFAULT_SETTINGS: ValidSettings = {
plugins: {},
scopes: [],
fileColors: DEFAULT_FILE_COLORS,
database: { inEditorResults: false, resolutionScopes: [] },
general: {
reopenLastProject: true,
confirmExit: true,
@@ -343,17 +340,6 @@ export function validateSettings(raw: Settings | unknown): ValidSettings {
plugins: Object.fromEntries(Object.entries(obj(root.plugins)).map(([id, values]) => [id, obj(values)])),
scopes: validateScopes(root.scopes),
fileColors: validateFileColors(root.fileColors),
database: {
inEditorResults: bool(obj(root.database).inEditorResults, d.database.inEditorResults),
resolutionScopes: (Array.isArray(obj(root.database).resolutionScopes)
? (obj(root.database).resolutionScopes as unknown[])
: []
).map((r) => ({
path: str(obj(r).path, ""),
dataSource: str(obj(r).dataSource, ""),
schema: str(obj(r).schema, ""),
})),
},
general: {
...validateGeneralExtras(g),
reopenLastProject: bool(g.reopenLastProject, d.general.reopenLastProject),
+1 -6
Переглянути файл
@@ -1086,17 +1086,12 @@ export const BEHAVIOR_PAGES: PageSpec[] = [
title: "Notifications",
group: APPEARANCE_GROUP,
order: 2,
keywords: ["balloon", "popup", "sound", "alerts", "system", "os"],
keywords: ["balloon", "popup", "sound", "alerts"],
sections: [
{
options: [
{ kind: "toggle", key: "notifications.balloons", label: "Display balloon notifications" },
{ kind: "toggle", key: "notifications.sound", label: "Play sound" },
{
kind: "toggle",
key: "notifications.systemNotifications",
label: "Enable system notifications",
},
],
},
{
+1 -19
Переглянути файл
@@ -1,13 +1,4 @@
{
"Unity Editor": "Unity Editor",
"Attach to Unity Process": "Attach to Unity Process",
"Open the project in Unity Editor, enable Editor Attaching and switch to Debug Mode. Select its process below. Stopping debugging disconnects without closing Unity.": "Open the project in Unity Editor, enable Editor Attaching and switch to Debug Mode. Select its process below. Stopping debugging disconnects without closing Unity.",
"No Unity Editor processes found. Open Unity Editor, then refresh.": "No Unity Editor processes found. Open Unity Editor, then refresh.",
"Install Unity Debugger": "Install Unity Debugger",
"Unity Debugger is not installed": "Unity Debugger is not installed",
"Debugger is not available": "Debugger is not available",
"Attach": "Attach",
"Installing…": "Installing…",
"moved from {oldPath}": "moved from {oldPath}",
"Symbolic link": "Symbolic link",
"Copy as TSV": "Copy as TSV",
@@ -1968,14 +1959,5 @@
"Non-Project Files": "Non-Project Files",
"file:src//*.ts && !file:*.test.ts — paths are relative to the project; // is any folders, * any characters. file[module]:pattern limits a pattern to a module.": "file:src//*.ts && !file:*.test.ts — paths are relative to the project; // is any folders, * any characters. file[module]:pattern limits a pattern to a module.",
"Clear File Color": "Clear File Color",
"Edit File Colors…": "Edit File Colors…",
"Enable system notifications": "Enable system notifications",
"In-Editor Results": "In-Editor Results",
"Show query results in the editor, under the statements that produced them": "Show query results in the editor, under the statements that produced them",
"SQL Resolution Scopes": "SQL Resolution Scopes",
"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.": "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.",
"Project data source": "Project data source",
"Project schema": "Project schema",
"Add Folder or File": "Add Folder or File",
"Paths are relative to the project root. The deepest folder or file that contains a file applies to it.": "Paths are relative to the project root. The deepest folder or file that contains a file applies to it."
"Edit File Colors…": "Edit File Colors…"
}
+1 -18
Переглянути файл
@@ -1,12 +1,4 @@
{
"Unity Editor": "Unity 编辑器",
"Attach to Unity Process": "附加到 Unity 进程",
"Open the project in Unity Editor, enable Editor Attaching and switch to Debug Mode. Select its process below. Stopping debugging disconnects without closing Unity.": "在 Unity 编辑器中打开项目,启用 Editor Attaching 并切换到 Debug Mode,然后在下方选择对应进程。停止调试会断开连接,Unity 编辑器会继续运行。",
"No Unity Editor processes found. Open Unity Editor, then refresh.": "未找到 Unity 编辑器进程。打开 Unity 编辑器后刷新。",
"Install Unity Debugger": "安装 Unity 调试器",
"Unity Debugger is not installed": "尚未安装 Unity 调试器",
"Attach": "附加",
"Installing…": "正在安装…",
"Symbolic link": "符号链接",
"Copy as TSV": "复制为 TSV",
"Copy as CSV": "复制为 CSV",
@@ -8360,14 +8352,5 @@
"Non-Project Files": "非项目文件",
"file:src//*.ts && !file:*.test.ts — paths are relative to the project; // is any folders, * any characters. file[module]:pattern limits a pattern to a module.": "file:src//*.ts && !file:*.test.ts —— 路径相对于项目;// 表示任意层文件夹,* 表示任意字符。file[module]:pattern 将模式限定在某个模块内。",
"Clear File Color": "清除文件颜色",
"Edit File Colors…": "编辑文件颜色…",
"Enable system notifications": "启用系统通知",
"In-Editor Results": "编辑器内结果",
"Show query results in the editor, under the statements that produced them": "在编辑器中、产生结果的语句下方显示查询结果",
"SQL Resolution Scopes": "SQL 解析作用域",
"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.": "这些文件夹和文件中的 SQL 按所选数据源解析:补全、检查和导航使用它的表;查询控制台也在它上面执行,除非在控制台工具栏中另选了数据源。",
"Project data source": "项目数据源",
"Project schema": "项目架构",
"Add Folder or File": "添加文件夹或文件",
"Paths are relative to the project root. The deepest folder or file that contains a file applies to it.": "路径相对于项目根目录。对某个文件生效的是包含它的最深一级文件夹或该文件本身。"
"Edit File Colors…": "编辑文件颜色…"
}
-1
Переглянути файл
@@ -383,7 +383,6 @@ const ICONS = {
"db-sequence": "openidea/database/sequence",
"db-plan": "openidea/database/plan",
"db-chart": "openidea/database/chart",
"db-in-editor-results": "openidea/database/inEditorResults",
"db-sort": "openidea/database/sort",
"db-folder": "openidea/database/folder",
"db-add": "openidea/database/addDropdown",
-4
Переглянути файл
@@ -1,4 +0,0 @@
<!-- OpenIDEA: in-editor results (text lines over a result grid) -->
<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
<path d="M2.5 2.5H10.5M2.5 5H7.5" stroke="#6C707E" stroke-linecap="round"/><rect x="2.5" y="7.5" width="11" height="6" rx="1" stroke="#6C707E"/><path d="M2.5 10.5H13.5M6.5 7.5V13.5" stroke="#6C707E"/>
</svg>

До

Ширина:  |  Висота:  |  Розмір: 373 B

-4
Переглянути файл
@@ -758,8 +758,6 @@ export interface NotificationService {
* silence what the IDE reports on its own, not the answer to a request.
*/
userInitiated?: boolean;
/** Skip the chime even when "Play sound" is on (e.g. native OS sound already played). */
silent?: boolean;
}): void;
/** Hides the balloon of the notification with `key` (it stays in the log), e.g. once its cause is gone. */
expire?(key: string): void;
@@ -1091,8 +1089,6 @@ export interface SettingsPageContribution {
component?: ComponentType;
/** The page edits settings that a project can override (Global / This project switch). */
projectScope?: boolean;
/** The scope the switch starts on (default: global). */
defaultScope?: "global" | "project";
}
/**
+2 -11
Переглянути файл
@@ -1,7 +1,7 @@
/** Notification center: balloons + history, backing `NotificationService`. */
import type { ReactNode } from "react";
import { create } from "zustand";
import { call, commands, isTauri, onIdeEvent } from "@/platform/ipc";
import { call, commands, onIdeEvent } from "@/platform/ipc";
import { buildToolRecovery } from "@/platform/buildToolRecovery";
import { txTemplate } from "@/platform/i18n";
import { useProject } from "@/platform/project";
@@ -154,16 +154,7 @@ export function notify(n: Parameters<NotificationService["notify"]>[0]): number
const rest = n.key ? s.items.filter((x) => x.key !== n.key) : s.items;
return { items: [item, ...rest].slice(0, MAX_HISTORY) };
});
// OS toast owns the chime when system notifications are on and the app is backgrounded.
const systemOn = useProject.getState().settings?.notifications?.systemNotifications !== false;
const backgrounded = typeof document !== "undefined" && !document.hasFocus();
if (balloon && prefs.sound && !n.silent && !(systemOn && backgrounded)) playSound();
if (balloon && isTauri()) {
// In the UI language, as the balloon shows it; a plugin's own text stays as written.
const shown = (text: string) => (n.verbatim ? text : txTemplate(text));
const plain = typeof n.body === "string" ? shown(n.body) : "";
void call(commands.showSystemNotification(shown(n.title), plain)).catch(() => {});
}
if (balloon && prefs.sound) playSound();
return id;
}