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

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

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

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

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

Refs #1436

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

Closes #3531

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

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

No files matched your search

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

Після

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

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

До

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

Створено
+131 -6
Переглянути файл
@@ -199,7 +199,7 @@ dependencies = [
"wayland-backend",
"wayland-client",
"wayland-protocols",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -5722,6 +5722,20 @@ dependencies = [
"serde_repr",
]
[[package]]
name = "mac-notification-sys"
version = "0.6.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fd604973958ddcc11b561193c0fb96ba146506ef2f231ef2e7c35fd2cbc9beca"
dependencies = [
"cc",
"log",
"objc2 0.6.5",
"objc2-foundation 0.3.2",
"time",
"uuid",
]
[[package]]
name = "mach2"
version = "0.6.0"
@@ -5994,6 +6008,20 @@ dependencies = [
"windows-sys 0.60.2",
]
[[package]]
name = "notify-rust"
version = "4.19.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57da5b5d3b7809bf71858da5a2818c3404ca4688c02c8abecdda0fcdec235df3"
dependencies = [
"futures-lite",
"log",
"mac-notification-sys",
"serde",
"tauri-winrt-notification",
"zbus 6.3.0",
]
[[package]]
name = "notify-types"
version = "2.1.0"
@@ -6666,6 +6694,7 @@ dependencies = [
"tauri-build",
"tauri-plugin-dialog",
"tauri-plugin-mcp-bridge",
"tauri-plugin-notification",
"tauri-plugin-opener",
"tauri-plugin-single-instance",
"tauri-plugin-updater",
@@ -8153,7 +8182,7 @@ dependencies = [
"once_cell",
"serde",
"sha2 0.11.1",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -9429,6 +9458,26 @@ dependencies = [
"windows-core",
]
[[package]]
name = "tauri-plugin-notification"
version = "2.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14a226bfb8189ec4ab2c1936e66330ad06c44d9f6c54a674338208491dee177f"
dependencies = [
"log",
"notify-rust",
"rand 0.10.3",
"serde",
"serde_json",
"serde_repr",
"tauri",
"tauri-plugin",
"thiserror 2.0.21",
"time",
"url",
"zbus 5.19.0",
]
[[package]]
name = "tauri-plugin-opener"
version = "2.7.2"
@@ -9448,7 +9497,7 @@ dependencies = [
"thiserror 2.0.21",
"url",
"windows",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -9464,7 +9513,7 @@ dependencies = [
"tokio",
"tracing",
"windows-sys 0.61.2",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -9647,6 +9696,17 @@ dependencies = [
"toml 1.1.8+spec-1.1.0",
]
[[package]]
name = "tauri-winrt-notification"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f37a6c354fd28fc9e322ed9bd47e3959576dad28c9d58ea1cf888cce1c7ccb36"
dependencies = [
"thiserror 2.0.21",
"windows",
"windows-version",
]
[[package]]
name = "tempfile"
version = "3.27.0"
@@ -12137,11 +12197,38 @@ dependencies = [
"uuid",
"windows-sys 0.61.2",
"winnow 1.0.4",
"zbus_macros",
"zbus_macros 5.19.0",
"zbus_names",
"zvariant",
]
[[package]]
name = "zbus"
version = "6.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6b4aae740b23927ceabed962431abab2cdefb9f7f885e5bbab062da09bf580e4"
dependencies = [
"async-trait",
"bitflags 2.13.2",
"endi",
"futures-core",
"hex",
"libc",
"ordered-stream",
"rustix",
"serde",
"serde_repr",
"socket2",
"uds_windows",
"uuid",
"windows-sys 0.61.2",
"winnow 1.0.4",
"zbus_macros 6.3.0",
"zbus_utils",
"zcheapstr",
"zruntime",
]
[[package]]
name = "zbus-secret-service-keyring-store"
version = "1.0.1"
@@ -12150,7 +12237,7 @@ checksum = "74801d001b9e7729adb4f1825b67b398185fed424749aa3d8bacf70417137d9a"
dependencies = [
"keyring-core",
"secret-service",
"zbus",
"zbus 5.19.0",
]
[[package]]
@@ -12168,6 +12255,18 @@ dependencies = [
"zvariant_utils",
]
[[package]]
name = "zbus_macros"
version = "6.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "37c9dd4beaf145c16fcb2902862f50da86e54aed13dd368ddf64a1d17e6b8529"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.9",
"zbus_utils",
]
[[package]]
name = "zbus_names"
version = "4.3.5"
@@ -12179,6 +12278,19 @@ dependencies = [
"zvariant",
]
[[package]]
name = "zbus_utils"
version = "6.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "af55e52da295311b368c45bcae221f020e28e97a2420360170ce389218e76ec7"
dependencies = [
"proc-macro2",
"quote",
"serde",
"syn 3.0.9",
"winnow 1.0.4",
]
[[package]]
name = "zcheapstr"
version = "1.1.0"
@@ -12335,6 +12447,19 @@ dependencies = [
"simd-adler32",
]
[[package]]
name = "zruntime"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ce6a55d4f521760475a30f7b96779508fe8c40dc834478709454dd1d5f0ebc72"
dependencies = [
"futures-core",
"futures-io",
"rustix",
"socket2",
"windows-sys 0.61.2",
]
[[package]]
name = "zune-core"
version = "0.5.3"
+1 -1
Переглянути файл
@@ -68,7 +68,7 @@ the [official plugins](plugins/official). The plugin API is still a preview.
- [Discord](https://discord.gg/2Zy4yn7gP) — questions, feedback and release news.
- WeChat group — scan to join:
<img src=".github/assets/wechat-group.png" alt="WeChat group QR code" width="200">
<img src=".github/assets/wechat-group-3.png" alt="WeChat group QR code" width="200">
- Contributing: see [CONTRIBUTING.md](CONTRIBUTING.md) and the [contributor docs](https://openidea.sh/en/contribute/setup).
+1 -1
Переглянути файл
@@ -68,7 +68,7 @@ Eklentileri Ayarlar › Eklentiler (Settings › Plugins) bölümünden kur ya d
- [Discord](https://discord.gg/2Zy4yn7gP): sorular, geri bildirim ve sürüm haberleri.
- WeChat grubu, katılmak için kodu okut:
<img src=".github/assets/wechat-group.png" alt="WeChat grubu QR kodu" width="200">
<img src=".github/assets/wechat-group-3.png" alt="WeChat grubu QR kodu" width="200">
- Katkıda bulunmak için: [CONTRIBUTING.md](CONTRIBUTING.md) ve [katkıcı belgeleri](https://openidea.sh/en/contribute/setup).
+1 -1
Переглянути файл
@@ -66,7 +66,7 @@ WebAssembly 组件运行;主题、图标主题和语言无需编写代码。
- [Discord](https://discord.gg/2Zy4yn7gP):提问、反馈和版本发布消息。
- 微信群,扫码加入:
<img src=".github/assets/wechat-group.png" alt="微信群二维码" width="200">
<img src=".github/assets/wechat-group-3.png" alt="微信群二维码" width="200">
- 参与贡献:参见 [CONTRIBUTING.md](CONTRIBUTING.md) 和[贡献者文档](https://openidea.sh/zh/contribute/setup)。
+32 -1
Переглянути файл
@@ -135,6 +135,8 @@ struct Shared {
/// [`IDLE_RELEASE`], in milliseconds (shorter in tests).
idle_release_ms: AtomicU64,
mcp_servers_hook: RwLock<Option<Arc<McpServersFn>>>,
/// Monotonic id for [`AgentEvent::Attention`] episodes.
attention_seq: AtomicU64,
}
/// What an agent offered in its last session, for the New Task page.
@@ -417,6 +419,7 @@ impl AgentManager {
probes: Mutex::new(HashMap::new()),
idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),
mcp_servers_hook: RwLock::new(None),
attention_seq: AtomicU64::new(0),
});
shared.paths.catalogs.subscribe(&shared);
let mut tasks = HashMap::new();
@@ -1695,6 +1698,28 @@ impl Task {
self.emit_task();
}
fn emit_attention(&self, reason: AgentAttentionReason) {
let n = self.shared.attention_seq.fetch_add(1, Ordering::Relaxed);
let tag = match reason {
AgentAttentionReason::Finished => "finished",
AgentAttentionReason::Input => "input",
AgentAttentionReason::Failed => "failed",
};
self.shared.emit(AgentEvent::Attention {
task: self.id.clone(),
event_id: format!("{}:{tag}:{n}", self.id),
reason,
});
}
/// After NeedsInput + optional auto-approve: notify only when the user must still answer.
fn emit_attention_if_input_pending(&self) {
let waiting = !self.permissions.lock().is_empty() && self.state.lock().task.status == AgentStatus::NeedsInput;
if waiting {
self.emit_attention(AgentAttentionReason::Input);
}
}
fn persist(&self) {
// Held from snapshot to rename, so saves land in order and none follows a delete.
let deleted = self.deleted.lock();
@@ -1797,8 +1822,11 @@ impl Task {
}
match (next, result) {
(Some(queued), _) => prompt = queued.prompt,
(None, Ok(_)) => {
(None, Ok(stop)) => {
self.set_status(AgentStatus::Ready, None);
if stop != "cancelled" {
self.emit_attention(AgentAttentionReason::Finished);
}
return self.release_when_idle();
}
(None, Err(failure)) => return self.fail(failure),
@@ -1869,6 +1897,7 @@ impl Task {
}
None => self.set_status(AgentStatus::Failed, Some(failure.message)),
}
self.emit_attention(AgentAttentionReason::Failed);
}
/// Adds `prompt` to the running turn when the agent takes that; gives it back otherwise.
@@ -2500,6 +2529,7 @@ impl Task {
self.permissions.lock().insert(id, tx);
self.set_status(AgentStatus::NeedsInput, None);
self.approve_pending();
self.emit_attention_if_input_pending();
let answer = rx.recv().ok().flatten();
let answers = answer
@@ -2583,6 +2613,7 @@ impl Task {
});
self.permissions.lock().insert(id, tx);
self.set_status(AgentStatus::NeedsInput, None);
self.emit_attention_if_input_pending();
let reply = rx.recv().ok().flatten();
let (response, chosen) = elicitation::answer(&form, reply.as_deref());
self.settle(entry, chosen);
+15
Переглянути файл
@@ -5,6 +5,15 @@ use serde::{Deserialize, Serialize};
use specta::Type;
use std::collections::BTreeMap;
/// Why a task needs the user's attention (native / in-app notify).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AgentAttentionReason {
Finished,
Input,
Failed,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AgentStatus {
@@ -666,6 +675,12 @@ pub enum AgentEvent {
},
/// The installed or configured agent providers changed.
Providers,
/// The task needs attention once (finished turn, explicit input, or failure).
Attention {
task: String,
event_id: String,
reason: AgentAttentionReason,
},
}
pub use ide_core::settings::{AgentMcpServer, McpTransport};
+174
Переглянути файл
@@ -3619,3 +3619,177 @@ async fn ephemeral_tasks_deny_write_permissions() {
);
mgr.shutdown();
}
fn attention_reasons(events: &[AgentEvent]) -> Vec<AgentAttentionReason> {
events
.iter()
.filter_map(|e| match e {
AgentEvent::Attention { reason, .. } => Some(*reason),
_ => None,
})
.collect()
}
/// `wait_for(Ready/Failed/…)` can return after status is written but before the
/// following `emit_attention` runs on the agent thread — poll the sink instead.
async fn wait_for_attention(events: &Mutex<Vec<AgentEvent>>, reason: AgentAttentionReason) {
for _ in 0..500 {
if attention_reasons(&events.lock()).contains(&reason) {
return;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
panic!("never saw Attention::{reason:?}: {:?}", *events.lock());
}
#[tokio::test(flavor = "multi_thread")]
async fn attention_finished_not_cancelled() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent.clone());
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
let sink = events.clone();
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
let done = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude".into(),
config: Vec::new(),
isolation: Isolation::Local,
base: None,
})
.await
.unwrap();
wait_for(&mgr, &done.id, AgentStatus::Ready).await;
wait_for_attention(&events, AgentAttentionReason::Finished).await;
events.lock().clear();
let cancelled = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("wait"),
provider: "claude".into(),
config: Vec::new(),
isolation: Isolation::Local,
base: None,
})
.await
.unwrap();
wait_for(&mgr, &cancelled.id, AgentStatus::Running).await;
mgr.cancel(&cancelled.id, None).unwrap();
wait_for(&mgr, &cancelled.id, AgentStatus::Ready).await;
// Give a late Finished emission a chance; cancellation must not produce one.
tokio::time::sleep(Duration::from_millis(50)).await;
assert!(
!attention_reasons(&events.lock()).contains(&AgentAttentionReason::Finished),
"cancelled must not notify finished: {:?}",
*events.lock()
);
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn attention_failed() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent {
request_error: Some((codes::INTERNAL_ERROR, "boom".into())),
auth_on_new: true,
..Default::default()
});
let mgr = manager(tmp.path(), agent);
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
let sink = events.clone();
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("Fix"),
provider: "claude".into(),
config: Vec::new(),
isolation: Isolation::Local,
base: None,
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Failed).await;
wait_for_attention(&events, AgentAttentionReason::Failed).await;
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn attention_input_not_auto_bypass() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent);
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
let sink = events.clone();
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
let asked = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("Fix"),
provider: "claude".into(),
config: Vec::new(),
isolation: Isolation::Local,
base: None,
})
.await
.unwrap();
wait_for(&mgr, &asked.id, AgentStatus::NeedsInput).await;
wait_for_attention(&events, AgentAttentionReason::Input).await;
events.lock().clear();
mgr.cancel(&asked.id, None).unwrap();
wait_for(&mgr, &asked.id, AgentStatus::Ready).await;
let bypassed = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("Fix"),
provider: "cursor".into(),
config: vec![AgentConfigChoice { id: config::CURSOR_APPROVAL.into(), value: "bypass".into() }],
isolation: Isolation::Local,
base: None,
})
.await
.unwrap();
wait_for(&mgr, &bypassed.id, AgentStatus::Ready).await;
tokio::time::sleep(Duration::from_millis(50)).await;
assert!(
!attention_reasons(&events.lock()).contains(&AgentAttentionReason::Input),
"auto-bypass must not notify input: {:?}",
*events.lock()
);
mgr.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn attention_not_emitted_on_restore() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent);
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude".into(),
config: Vec::new(),
isolation: Isolation::Local,
base: None,
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
mgr.shutdown();
let restored = manager(tmp.path(), Arc::new(FakeAgent::default()));
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
let sink = events.clone();
let tasks = restored.subscribe(Arc::new(move |e| sink.lock().push(e)));
assert!(tasks.iter().any(|t| t.id == task.id));
tokio::time::sleep(Duration::from_millis(50)).await;
assert!(attention_reasons(&events.lock()).is_empty(), "snapshot restore must not re-notify: {:?}", *events.lock());
restored.shutdown();
}
+11 -1
Переглянути файл
@@ -71,6 +71,8 @@ pub struct Settings {
pub scopes: Vec<NamedScope>,
/// Appearance & Behavior › File Colors.
pub file_colors: FileColorSettings,
/// Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes.
pub database: DatabaseSettings,
/// Plugin settings (`[contributes.settings]`): plugin id → its values by key.
#[specta(type = BTreeMap<String, BTreeMap<String, specta_typescript::Unknown>>)]
pub plugins: BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
@@ -508,6 +510,7 @@ impl Default for Settings {
agent_security: AgentSecuritySettings::default(),
scopes: Vec::new(),
file_colors: FileColorSettings::default(),
database: DatabaseSettings::default(),
plugins: BTreeMap::new(),
}
}
@@ -647,13 +650,20 @@ impl Default for DateFormatSettings {
pub struct NotificationSettings {
pub balloons: bool,
pub sound: bool,
/// Mirror balloon notifications to the OS when no OpenIDEA window is focused.
#[serde(default = "default_true")]
pub system_notifications: bool,
/// Group id → display; groups not listed use their default.
pub groups: BTreeMap<String, NotificationGroupSettings>,
}
fn default_true() -> bool {
true
}
impl Default for NotificationSettings {
fn default() -> Self {
Self { balloons: true, sound: false, groups: BTreeMap::new() }
Self { balloons: true, sound: false, system_notifications: true, groups: BTreeMap::new() }
}
}
+24
Переглянути файл
@@ -241,6 +241,30 @@ impl Default for LogLevelColors {
}
}
/// Database settings: Query Execution and SQL Resolution Scopes.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct DatabaseSettings {
/// A console's result sets show under the statements that produced them, in the editor,
/// instead of in the Services view's result tabs.
pub in_editor_results: bool,
/// Languages & Frameworks › SQL Resolution Scopes: the data source SQL in a file or folder
/// resolves against (completion, inspections, navigation), most specific path first.
pub resolution_scopes: Vec<SqlResolutionScope>,
}
/// One row of SQL Resolution Scopes.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct SqlResolutionScope {
/// Project-relative file or folder, `/`-separated; empty for the whole project.
pub path: String,
/// Data source id.
pub data_source: String,
/// Schema unqualified names resolve in; empty for the data source's default.
pub schema: String,
}
/// Build, Execution, Deployment › Console.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
+6
Переглянути файл
@@ -120,6 +120,12 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
"stdio",
"Install GDB 14 or newer (apt install gdb, dnf install gdb, brew install gdb)",
),
"unity" => cfg(
"unity-debug",
&[],
"stdio",
"Install Unity Debugger in Settings > Language Servers, or configure the unity-debug tool path",
),
"rdbg" => cfg("rdbg", &["-O", "--port", PORT_PLACEHOLDER, "-c"], "tcp", "gem install debug"),
// A jdtls bundle: the session is started through jdtls and reached via `debugServer`.
"java-debug" => cfg(
+1
Переглянути файл
@@ -12,6 +12,7 @@ use std::path::Path;
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum AttachKind {
Unity,
Java,
Node,
Python,
+15
Переглянути файл
@@ -19,6 +19,7 @@ mod jvm_memory;
pub mod kotlin;
pub mod kotlin_lsp;
mod session;
pub mod unity;
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
use connection::{Connection, DapError};
@@ -1121,6 +1122,16 @@ impl DebugManager {
let _ = tokio::time::timeout(INIT_TIMEOUT, initialized.wait_for(|v| *v)).await;
}
if s.adapter == "unity" {
if launch_result.is_none()
&& let Some(launch) = launch.as_mut()
{
launch.await?;
launch_result = Some(());
}
unity::wait_for_threads(s).await?;
}
// A fresh adapter has no breakpoints, so a file with none enabled needs no request; the
// others go out together, as VS Code sends them, instead of one round trip per file.
let (files, idle): (Vec<_>, Vec<_>) = self
@@ -1202,6 +1213,10 @@ impl DebugManager {
if let Some(link) = s.jdwp_link.lock().as_ref() {
link.release();
}
if s.adapter == "unity" {
unity::settle_startup(s).await;
s.emit(ide_core::event::DebugEvent::Initialized);
}
Ok(())
}
+15 -2
Переглянути файл
@@ -17,7 +17,7 @@ use std::process::Stdio;
use std::sync::Arc;
use std::sync::Weak;
use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
use std::time::Duration;
use std::time::{Duration, Instant};
use tokio::io::{AsyncRead, AsyncReadExt};
use tokio::process::Child;
use tokio::sync::{mpsc, watch};
@@ -116,6 +116,7 @@ pub(crate) struct Session {
pub jvm_memory: tokio::sync::Mutex<crate::JvmMemoryState>,
/// Used only by a kotlin-lsp session: see [`Session::kotlin_lsp_quirks`].
pub(crate) quirks: kotlin_lsp::Quirks,
pub(crate) unity_startup_activity: Mutex<Instant>,
}
/// Which threads of the program are suspended: each from its `stopped` event until a
@@ -270,6 +271,7 @@ impl Session {
kotlin_mirror: Mutex::new(None),
jvm_memory: tokio::sync::Mutex::default(),
quirks: kotlin_lsp::Quirks::default(),
unity_startup_activity: Mutex::new(Instant::now()),
}
}
@@ -716,6 +718,15 @@ pub(crate) async fn event_loop(
}
async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut body: Value) {
if s.adapter == "unity"
&& event == "output"
&& body
.get("output")
.and_then(Value::as_str)
.is_some_and(|text| text.starts_with("Loaded assembly:") || text.starts_with("Resolved pending breakpoint"))
{
*s.unity_startup_activity.lock() = Instant::now();
}
if let Some(mirror) = s.kotlin_mirror.lock().as_ref() {
mirror.translate(&mut body);
}
@@ -724,7 +735,9 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
match event {
"initialized" => {
s.initialized.send_replace(true);
s.emit(DebugEvent::Initialized);
if s.adapter != "unity" {
s.emit(DebugEvent::Initialized);
}
}
"stopped" => {
let all = body.get("allThreadsStopped").and_then(Value::as_bool).unwrap_or(false);
+47 -2
Переглянути файл
@@ -158,6 +158,7 @@ struct Script {
/// `launch`, and a `configurationDone` sent while it runs is refused with `notStopped`.
gdb15_starts_at_launch: bool,
launch_after_configuration: bool,
empty_thread_responses: usize,
/// Requests of the adapter's own (js-debug's `setCustomBreakpoints`…) answered with an empty body.
accept: &'static [&'static str],
/// Requests of the adapter's own answered with a body and followed by events.
@@ -198,6 +199,7 @@ impl Default for Script {
close_during_startup: false,
gdb15_starts_at_launch: false,
launch_after_configuration: false,
empty_thread_responses: 0,
accept: &[],
custom: None,
}
@@ -244,6 +246,8 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
let mut held: Vec<Value> = Vec::new();
let mut stopped = false;
let mut running = false;
let mut thread_requests = 0;
let mut unity = false;
macro_rules! send {
($v:expr) => {{
let mut v: Value = $v;
@@ -268,13 +272,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
}
match msg["command"].as_str().unwrap_or_default() {
"initialize" => {
unity = msg["arguments"]["adapterID"] == "unity";
if let Some(delay) = script.delay_initialize {
tokio::time::sleep(delay).await;
}
ok!(
msg,
json!({
"supportsConfigurationDoneRequest": true,
"supportsConfigurationDoneRequest": !unity,
"supportsCompletionsRequest": true,
"supportsTerminateRequest": script.supports_terminate,
"supportsSetVariable": true,
@@ -293,8 +298,15 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
// defers it sends late).
send!(json!({"type": "event", "event": "initialized"}));
}
if unity {
send!(json!({"type": "event", "event": "initialized"}));
}
}
"launch" | "attach" => {
if unity {
ok!(msg, Value::Null);
continue;
}
if script.gdb15_starts_at_launch {
// GDB 15 starts the program here and answers `launch` right away.
running = true;
@@ -448,7 +460,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
tokio::time::sleep(Duration::from_millis(50)).await;
ok!(msg, json!({"threads": [{"id": 1, "name": "\"main\"@1"}]}));
}
"threads" => ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]})),
"threads" => {
thread_requests += 1;
if thread_requests <= script.empty_thread_responses {
ok!(msg, json!({"threads": []}));
} else {
ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]}));
}
}
"stackTrace" => ok!(
msg,
json!({"stackFrames": [
@@ -878,6 +897,32 @@ async fn stop_terminates_and_disconnects() {
assert!(h.manager.threads(id).await.is_err());
}
#[tokio::test]
async fn unity_attach_waits_for_mono_and_disconnects_without_terminating_editor() {
let h = harness(Script { empty_thread_responses: 2, ..Script::default() });
h.manager.set_breakpoints(PathBuf::from("/p/a.cs"), vec![bp(4)]).await.unwrap();
let start = h.start(LaunchConfig {
adapter: "unity".into(),
request: "attach".into(),
program: None,
extra_json: Some(json!({ "name": "Unity Editor (42)", "__exceptionOptions": [] }).to_string()),
..config()
});
let ready = async {
h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;
let commands = h.commands();
let before_breakpoints = commands.iter().take_while(|c| *c != "setBreakpoints");
assert!(before_breakpoints.filter(|c| *c == "threads").count() >= 3);
assert!(commands.iter().any(|c| c == "setBreakpoints"));
};
let (id, ()) = tokio::join!(start, ready);
let id = id.unwrap();
assert_eq!(h.request("attach")["arguments"]["name"], "Unity Editor (42)");
h.manager.stop(id).await.unwrap();
assert!(!h.commands().iter().any(|c| c == "launch" || c == "terminate"));
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], false);
}
#[tokio::test]
async fn concurrent_sessions_are_independent() {
let h = harness(Script::default());
+187
Переглянути файл
@@ -0,0 +1,187 @@
//! Lists the Unity Editors to attach to through UnityDebug's discovery (`unity-debug list`).
use crate::{
adapter,
attach::{AttachKind, AttachableProcess},
};
use ide_core::{IdeError, IdeResult};
use std::{path::PathBuf, process::Stdio, time::Duration};
/// Waits until Mono reports its threads.
pub(crate) async fn wait_for_threads(session: &crate::session::Session) -> IdeResult<()> {
tokio::time::timeout(Duration::from_secs(20), async {
loop {
let body = session.conn.request_timeout("threads", serde_json::json!({}), Duration::from_secs(5)).await?;
if body.get("threads").and_then(serde_json::Value::as_array).is_some_and(|t| !t.is_empty()) {
return Ok(());
}
tokio::time::sleep(Duration::from_millis(100)).await;
}
})
.await
.map_err(|_| {
IdeError::unavailable(
"Unity debugger did not become ready. Enable Editor Attaching and Debug Mode in Unity, then retry.",
)
})?
}
// Mono binds breakpoints asynchronously and resumes threads itself during startup: wait for that burst to end.
pub(crate) async fn settle_startup(session: &crate::session::Session) {
*session.unity_startup_activity.lock() = std::time::Instant::now();
let _ = tokio::time::timeout(Duration::from_secs(3), async {
while session.unity_startup_activity.lock().elapsed() < Duration::from_secs(1) {
tokio::time::sleep(Duration::from_millis(50)).await;
}
})
.await;
}
pub fn require_runtime(cwd: &std::path::Path) -> IdeResult<()> {
if cfg!(unix) && ide_core::tool_path::find_command("mono", &ide_core::tool_path::search_path(), cwd).is_none() {
return Err(IdeError::unavailable(
"Unity Debugger requires Mono. Install Mono, make sure mono is on PATH, then refresh the Unity process list.",
));
}
Ok(())
}
const NOT_INSTALLED: &str = "debug adapter `unity` not found. Install Unity Debugger in Settings > Language Servers or configure the unity-debug tool path";
pub async fn editors(command: Option<String>, cwd: PathBuf) -> IdeResult<Vec<AttachableProcess>> {
require_runtime(&cwd)?;
let command = command.unwrap_or_else(|| "unity-debug".into());
let lookup = command.clone();
let dir = cwd.clone();
let binary = tokio::task::spawn_blocking(move || adapter::resolve_binary(&lookup, &dir))
.await
.map_err(|e| IdeError::internal(e.to_string()))?
.ok_or_else(|| IdeError::unavailable(NOT_INSTALLED))?;
let mut cmd = tokio::process::Command::new(binary);
ide_core::process::prepare(cmd.as_std_mut());
cmd.arg("list")
.current_dir(&cwd)
.env("PATH", ide_core::tool_path::search_path())
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
let out = tokio::time::timeout(Duration::from_secs(15), cmd.output())
.await
.map_err(|_| {
IdeError::unavailable("Unity process discovery timed out. Check that Unity Editor is responsive.")
})?
.map_err(|e| IdeError::unavailable(format!("Cannot start Unity process discovery: {e}")))?;
if !out.status.success() {
return Err(IdeError::unavailable(format!(
"Unity process discovery failed: {}",
String::from_utf8_lossy(&out.stderr).trim()
)));
}
let mut rows = parse_editors(&String::from_utf8_lossy(&out.stdout));
#[cfg(windows)]
if !rows.is_empty() {
match editor_process_ids() {
Ok(editors) => rows.retain(|p| editors.contains(&p.pid)),
Err(error) => tracing::warn!(%error, "Unity process filtering failed; using adapter discovery results"),
}
}
// The Editor of the open project comes first; the user picks which one to attach to.
let path = cwd.join("Library/EditorInstance.json");
let pid = std::fs::File::open(path).ok().and_then(|file| {
use std::io::Read;
let json: serde_json::Value = serde_json::from_reader(file.take(4096)).ok()?;
json.get("process_id")?.as_u64().and_then(|n| u32::try_from(n).ok())
});
for row in &mut rows {
if Some(row.pid) == pid {
row.command_line = cwd.to_string_lossy().into_owned();
}
}
rows.sort_by_key(|p| Some(p.pid) != pid);
Ok(rows)
}
#[cfg(windows)]
fn editor_process_ids() -> IdeResult<std::collections::HashSet<u32>> {
use std::collections::HashMap;
use windows_sys::Win32::{
Foundation::{CloseHandle, INVALID_HANDLE_VALUE},
System::Diagnostics::ToolHelp::{
CreateToolhelp32Snapshot, PROCESSENTRY32W, Process32FirstW, Process32NextW, TH32CS_SNAPPROCESS,
},
};
let mut unity = HashMap::new();
// The adapter also finds the asset import worker processes: keep the Unity processes whose parent isn't Unity.
unsafe {
let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if snapshot == INVALID_HANDLE_VALUE {
return Err(std::io::Error::last_os_error().into());
}
let mut entry = PROCESSENTRY32W { dwSize: std::mem::size_of::<PROCESSENTRY32W>() as u32, ..std::mem::zeroed() };
let mut found = Process32FirstW(snapshot, &mut entry);
if found == 0 {
let error = std::io::Error::last_os_error();
CloseHandle(snapshot);
return Err(error.into());
}
while found != 0 {
let end = entry.szExeFile.iter().position(|c| *c == 0).unwrap_or(entry.szExeFile.len());
let name = String::from_utf16_lossy(&entry.szExeFile[..end]);
if name.eq_ignore_ascii_case("Unity.exe") {
unity.insert(entry.th32ProcessID, entry.th32ParentProcessID);
}
found = Process32NextW(snapshot, &mut entry);
}
CloseHandle(snapshot);
}
Ok(unity.iter().filter_map(|(&pid, parent)| (!unity.contains_key(parent)).then_some(pid)).collect())
}
pub fn parse_editors(output: &str) -> Vec<AttachableProcess> {
let mut editors = Vec::new();
for line in output.lines() {
let line = line.trim().trim_start_matches('\u{feff}');
if !line.starts_with("Unity Editor (") {
continue;
}
// 3.0.1 prints `Unity Editor (Unity) (123)`; later versions append the project name.
let Some((name, pid, project)) = line.match_indices(" (").find_map(|(at, _)| {
let (id, project) = line[at + 2..].split_once(')')?;
let pid = id.parse::<u32>().ok().filter(|n| *n > 0)?;
Some((&line[..at], pid, project))
}) else {
continue;
};
if editors.iter().any(|p: &AttachableProcess| p.pid == pid) {
continue;
}
editors.push(AttachableProcess {
pid,
name: "Unity Editor".into(),
command_line: if project.trim().is_empty() { name.into() } else { project.trim().into() },
kind: AttachKind::Unity,
adapter: "unity".into(),
host: None,
port: None,
});
}
editors.sort_by(|a, b| a.command_line.cmp(&b.command_line).then(a.pid.cmp(&b.pid)));
editors
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_editor_ids_and_projects_without_mistaking_players_or_logs_for_editors() {
let rows = parse_editors(
"\u{feff}Unity Editor (Unity) (42) Game (Test)\r\nUnity Editor (7) My Game\nUnity Editor (42) duplicate\nWindowsPlayer (123) Player\nUnity Hub (44)\nUnity Editor (invalid)\nUnity Editor (0)\nlog text",
);
assert_eq!(rows.len(), 2);
assert_eq!((rows[0].pid, rows[0].command_line.as_str()), (42, "Game (Test)"));
assert_eq!(rows[1].pid, 7);
assert!(rows.iter().all(|p| p.kind == AttachKind::Unity && p.adapter == "unity"));
}
}
+187
Переглянути файл
@@ -0,0 +1,187 @@
//! Attaches to a real Unity Editor, with its own temporary project and Editor instance.
//! OPENIDEA_UNITY_EDITOR=<Unity.exe> OPENIDEA_UNITY_ADAPTER=<UnityDebug.exe>
//! cargo test -p ide-dap --test unity -- --ignored --nocapture
use ide_core::{IdeEvent, SharedSink, event::DebugEvent};
use ide_dap::{Breakpoint, DebugManager, LaunchConfig, SessionOwner, StepKind};
use ide_language::LanguageRegistry;
use parking_lot::Mutex;
use std::{collections::BTreeMap, path::PathBuf, sync::Arc, time::Duration};
const SCRIPT: &str = r#"using System.IO;
using UnityEditor;
using UnityEngine;
[InitializeOnLoad]
public static class OpenIdeaAttachProbe
{
static readonly string Root = Directory.GetParent(Application.dataPath).FullName;
static OpenIdeaAttachProbe()
{
EditorApplication.update += Tick;
}
static void Tick()
{
if (EditorApplication.isCompiling || EditorApplication.isUpdating) return;
if (!File.Exists(Path.Combine(Root, "ready")))
File.WriteAllText(Path.Combine(Root, "ready"), System.Diagnostics.Process.GetCurrentProcess().Id.ToString());
if (File.Exists(Path.Combine(Root, "exit"))) { EditorApplication.Exit(0); return; }
if (!File.Exists(Path.Combine(Root, "go"))) return;
File.Delete(Path.Combine(Root, "go"));
int result = Hit(41);
File.WriteAllText(Path.Combine(Root, "done"), result.ToString());
}
static int Hit(int seed)
{
int answer = seed + 1;
return answer;
}
}
"#;
async fn stopped(events: &Mutex<Vec<IdeEvent>>, expected_reason: &str) -> i64 {
for _ in 0..600 {
if let Some(thread) = events.lock().iter().find_map(|e| match e {
IdeEvent::Debug { event: DebugEvent::Stopped { thread_id, reason, .. }, .. }
if reason == expected_reason =>
{
Some(*thread_id)
}
_ => None,
}) {
return thread;
}
tokio::time::sleep(Duration::from_millis(50)).await;
}
let events = events.lock();
panic!("No breakpoint/step event: {:?}", &events[events.len().saturating_sub(16)..]);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[ignore = "needs a licensed Unity Editor and the Unity DAP adapter"]
async fn real_editor_attach_breakpoint_step_variables_and_detach() {
let editor = std::env::var("OPENIDEA_UNITY_EDITOR").expect("OPENIDEA_UNITY_EDITOR");
let adapter = std::env::var("OPENIDEA_UNITY_ADAPTER").expect("OPENIDEA_UNITY_ADAPTER");
let target = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target").canonicalize().unwrap();
// Keep the Editor log for diagnosing a failure.
let root = tempfile::Builder::new().prefix("unity-dap-smoke-").tempdir_in(target).unwrap().keep();
let root = root.to_string_lossy().trim_start_matches(r"\\?\").replace('\\', "/");
let root = PathBuf::from(root);
std::fs::create_dir_all(root.join("Assets/Editor")).unwrap();
std::fs::create_dir(root.join("ProjectSettings")).unwrap();
std::fs::create_dir(root.join("Packages")).unwrap();
std::fs::write(
root.join("ProjectSettings/ProjectVersion.txt"),
format!(
"m_EditorVersion: {}\n",
PathBuf::from(&editor).ancestors().nth(2).and_then(|p| p.file_name()).unwrap().to_string_lossy()
),
)
.unwrap();
std::fs::write(root.join("Packages/manifest.json"), r#"{"dependencies":{}}"#).unwrap();
let source = root.join("Assets/Editor/OpenIdeaAttachProbe.cs");
std::fs::write(&source, SCRIPT).unwrap();
let mut command = tokio::process::Command::new(&editor);
ide_core::process::prepare(command.as_std_mut());
// The test project has no packages: skip the package manager.
command
.args(["-batchmode", "-nographics", "-noUpm", "-debugCodeOptimization", "-projectPath"])
.arg(&root)
.arg("-logFile")
.arg(root.join("Editor.log"))
.current_dir(&root)
.kill_on_drop(true);
let mut child = command.spawn().unwrap();
let pid = child.id().unwrap();
eprintln!("Isolated Unity pid {pid}, project {}", root.display());
for _ in 0..1200 {
if root.join("ready").exists() {
break;
}
assert!(child.try_wait().unwrap().is_none(), "Unity exited; inspect {}/Editor.log", root.display());
tokio::time::sleep(Duration::from_millis(100)).await;
}
assert!(root.join("ready").exists(), "Editor failed to load the test script");
let rows = ide_dap::unity::editors(Some(adapter.clone()), root.clone()).await.unwrap();
assert!(rows.iter().any(|p| p.pid == pid), "test Editor absent: {rows:?}");
let events: Arc<Mutex<Vec<IdeEvent>>> = Arc::default();
let saved = events.clone();
let sink: SharedSink = Arc::new(move |event| saved.lock().push(event));
let manager = DebugManager::new(Arc::new(LanguageRegistry::from_configs(Vec::new())));
let line = SCRIPT.lines().position(|l| l.contains("int answer =")).unwrap() as u32;
manager
.set_breakpoints(
source.clone(),
vec![Breakpoint { line, condition: None, hit_condition: None, log_message: None, enabled: true }],
)
.await
.unwrap();
let start = || {
manager.start_with(
LaunchConfig {
name: format!("Unity Editor ({pid})"),
adapter: "unity".into(),
request: "attach".into(),
program: None,
args: vec![],
cwd: Some(root.clone().into()),
env: BTreeMap::new(),
extra_json: Some(
serde_json::json!({ "name": format!("Unity Editor ({pid})"), "__exceptionOptions": [] })
.to_string(),
),
},
SessionOwner::new("smoke", sink.clone()),
|_| Some(adapter.clone()),
)
};
let session = start().await.unwrap();
eprintln!("Attached; breakpoint states: {:?}", manager.breakpoint_states(&source));
// Mono is ready to run once the start returns.
assert!(!manager.threads(session).await.unwrap().is_empty());
std::fs::write(root.join("go"), "").unwrap();
let thread = stopped(&events, "breakpoint").await;
let frames = manager.stack_trace(session, thread).await.unwrap();
assert!(!frames.is_empty(), "Empty breakpoint stack: {:?}", events.lock());
assert_eq!(frames[0].line, line);
let scopes = manager.scopes(session, frames[0].id).await.unwrap();
let variables = manager.variables(session, scopes[0].variables_reference).await.unwrap();
assert!(variables.iter().any(|v| v.name == "seed" && v.value == "41"), "{variables:?}");
assert_eq!(manager.evaluate(session, Some(frames[0].id), "seed + 1".into()).await.unwrap().value, "42");
events.lock().clear();
manager.step(session, thread, StepKind::Over).await.unwrap();
let thread = stopped(&events, "step").await;
let frames = manager.stack_trace(session, thread).await.unwrap();
assert!(!frames.is_empty(), "Empty step stack: {:?}", events.lock());
assert!(frames[0].line > line);
// Detaching at a breakpoint resumes the Editor.
manager.stop(session).await.unwrap();
verify_resumed(&root, &mut child).await;
// Attaching again to the same Editor hits the existing breakpoint.
std::fs::remove_file(root.join("done")).unwrap();
events.lock().clear();
let session = start().await.unwrap_or_else(|error| {
let events = events.lock();
panic!("Reattach failed: {error:?}, recent events: {:?}", &events[events.len().saturating_sub(12)..]);
});
std::fs::write(root.join("go"), "").unwrap();
let thread = stopped(&events, "breakpoint").await;
assert_eq!(manager.stack_trace(session, thread).await.unwrap()[0].line, line);
manager.stop(session).await.unwrap();
verify_resumed(&root, &mut child).await;
std::fs::write(root.join("exit"), "").unwrap();
assert!(tokio::time::timeout(Duration::from_secs(30), child.wait()).await.unwrap().unwrap().success());
eprintln!("Verified discovery, attachment, breakpoint, locals, evaluation, step, detach and reattachment");
}
async fn verify_resumed(root: &std::path::Path, child: &mut tokio::process::Child) {
let path = root.join("done");
for _ in 0..100 {
assert!(child.try_wait().unwrap().is_none(), "disconnect terminated the Unity Editor");
if std::fs::read_to_string(&path).is_ok_and(|text| text == "42") {
return;
}
tokio::time::sleep(Duration::from_millis(100)).await;
}
panic!("Unity did not complete the script after disconnect: {:?}", std::fs::read_to_string(path));
}
+40 -16
Переглянути файл
@@ -650,28 +650,52 @@ fn structure_plan(
kind: BuildKind,
cache: &Path,
) -> IdeResult<Option<compile::BuildPlan>> {
let (roots, jdk) = structure_inputs(root, settings, detected);
compile::structure_plan(
root,
&settings.project_structure,
&roots,
jdk.as_ref(),
&settings.languages.java.language_level,
kind,
cache,
)
let (ps, roots, jdk) = structure_inputs(root, settings, detected);
compile::structure_plan(root, &ps, &roots, jdk.as_ref(), &settings.languages.java.language_level, kind, cache)
}
/// The roots and JDK a build of a project without a build tool uses.
/// The Project Structure, roots and JDK a build of a project without a build tool uses.
/// An Eclipse project's `.classpath` libraries and its web content folder count as if they
/// were configured, and a web project with no artifacts gets IDEA's `<name>:war exploded`.
pub(crate) fn structure_inputs(
root: &Path,
settings: &Settings,
detected: &[ide_workspace::roots::SourceFolder],
) -> (compile::StructureRoots, Option<compile::StructureJdk>) {
use ide_workspace::roots::{ProjectRoots, RootKind};
let roots = ProjectRoots::compute(detected.to_vec(), &settings.project_structure);
) -> (ide_core::settings::ProjectStructureSettings, compile::StructureRoots, Option<compile::StructureJdk>) {
use ide_core::settings::{ArtifactConfig, ArtifactKind, FacetConfig, ProjectLibrary};
use ide_workspace::roots::{ProjectRoots, RootKind, eclipse};
let mut ps = settings.project_structure.clone();
let mut included = Vec::new();
if let Some(cp) = eclipse::classpath(root).filter(|cp| !cp.libraries.is_empty()) {
let name = "Eclipse classpath".to_owned();
if !ps.libraries.iter().any(|l| l.name == name) {
ps.libraries.push(ProjectLibrary { name: name.clone(), classes: cp.libraries, ..Default::default() });
}
included.push(name);
}
if !ps.facets.iter().any(|f| f.kind == "web")
&& let Some(web) = eclipse::web_root(root)
{
ps.facets.push(FacetConfig {
kind: "web".into(),
module: ".".into(),
descriptor: format!("{web}/WEB-INF/web.xml"),
web_root: web,
});
if ps.artifacts.is_empty() {
let name = root.file_name().map_or_else(|| "app".into(), |n| n.to_string_lossy().into_owned());
ps.artifacts.push(ArtifactConfig {
name: format!("{name}:war exploded"),
kind: ArtifactKind::WarExploded,
module: ".".into(),
include_libraries: included,
..Default::default()
});
}
}
let roots = ProjectRoots::compute(detected.to_vec(), &ps);
let of = |kind: RootKind| roots.roots.iter().filter(|r| r.kind == kind).map(|r| root.join(&r.path)).collect();
let module = settings.project_structure.module_settings(root, root);
let module = ps.module_settings(root, root);
let level = module
.map(|m| m.language_level.as_str())
.filter(|l| !l.trim().is_empty())
@@ -690,7 +714,7 @@ pub(crate) fn structure_inputs(
test_resources: of(RootKind::TestResources),
excluded: of(RootKind::Excluded),
};
(roots, jdk)
(ps, roots, jdk)
}
fn cmake_plan(root: &Path, kind: BuildKind, configs: &[ide_run::RunConfig], id: &str) -> IdeResult<compile::BuildPlan> {
+45
Переглянути файл
@@ -12,6 +12,25 @@ use std::path::PathBuf;
/// Starts a session owned by this window: its events (and those of child sessions) go here only.
pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> IdeResult<DebugSessionId> {
host.require_trust(window)?;
let unity_pid = if config.adapter == "unity" {
if config.request != "attach" {
return Err(ide_core::IdeError::invalid("Unity debugging only supports attachment to a running Editor"));
}
let arguments = launch_arguments(&config)?;
let pid = arguments["name"]
.as_str()
.and_then(|name| name.strip_prefix("Unity Editor ("))
.and_then(|name| name.strip_suffix(')'))
.and_then(|pid| pid.parse::<u32>().ok());
if let Some(pid) = pid {
require_unity_editor(pid)?;
}
let cwd = config.cwd.as_ref().map(|path| path.as_ref()).unwrap_or_else(|| std::path::Path::new("."));
unity::require_runtime(cwd)?;
pid
} else {
None
};
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
if config.adapter == "debugpy"
&& config.request == "launch"
@@ -100,12 +119,26 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
let server_port = debug_server_port(&config);
let result = host.debugger.start_with(config, owner, custom).await;
flush_output();
if result.is_err()
&& let Some(pid) = unity_pid
{
require_unity_editor(pid)?;
}
if let (Ok(id), Some(port)) = (&result, server_port) {
attach_jvm_inspector(host, window, *id, port);
}
result
}
fn require_unity_editor(pid: u32) -> IdeResult<()> {
if !ide_core::process::process_alive(pid) {
return Err(ide_core::IdeError::unavailable(format!(
"Unity Editor (PID {pid}) is no longer running. Refresh the Unity process list and select a running Editor."
)));
}
Ok(())
}
/// The port of the java-debug server this machine's jdtls started; `debugServer` as `host:port`
/// names an adapter on another machine, whose jdtls is not ours to ask.
fn debug_server_port(config: &LaunchConfig) -> Option<u16> {
@@ -460,6 +493,17 @@ pub async fn debug_free_port(host: &Host, window: &str) -> IdeResult<u16> {
ide_dap::adapter::free_port().map_err(ide_core::IdeError::from)
}
pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
host.require_trust(window)?;
let project = host.project(window)?;
if ide_workspace::unity::detect(&project.root).is_none() {
return Err(ide_core::IdeError::invalid("Open a Unity project before attaching to the Editor"));
}
let command = ide_sdk::apply::tool_command(&project.root, &project.settings.effective(), "unity-debug")
.map(|p| p.to_string_lossy().into_owned());
unity::editors(command, project.root.clone()).await
}
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
pub async fn debug_listen_for_jvm(
@@ -664,6 +708,7 @@ pub(crate) fn register(d: &mut Dispatcher) {
});
d.add("debug_attachable_processes", |c| async move { debug_attachable_processes(&c.host, &c.window).await });
d.add("debug_free_port", |c| async move { debug_free_port(&c.host, &c.window).await });
d.add("debug_unity_processes", |c| async move { debug_unity_processes(&c.host, &c.window).await });
d.add("debug_listen_for_jvm", |c| async move {
debug_listen_for_jvm(&c.host, &c.window, c.arg("request")?, c.arg("host")?, c.arg("port")?).await
});
+8 -7
Переглянути файл
@@ -205,8 +205,8 @@ pub async fn run_tomcat_installations(
/// Id prefix of a Project Structure WAR artifact (a project without a build tool).
const PROJECT_ARTIFACT: &str = "project:";
fn project_web_artifacts(settings: &ide_core::settings::Settings) -> Vec<ide_build::web::WebArtifact> {
ide_build::compile::structure_web_artifacts(&settings.project_structure)
fn project_web_artifacts(ps: &ide_core::settings::ProjectStructureSettings) -> Vec<ide_build::web::WebArtifact> {
ide_build::compile::structure_web_artifacts(ps)
.into_iter()
.map(|a| ide_build::web::WebArtifact {
id: format!("{PROJECT_ARTIFACT}{}", a.name),
@@ -228,20 +228,19 @@ fn build_project_war(
cache: &std::path::Path,
) -> IdeResult<()> {
use ide_build::compile;
let artifact = settings
.project_structure
let (ps, roots, jdk) = crate::ops::build::structure_inputs(root, settings, detected);
let artifact = ps
.artifacts
.iter()
.find(|a| a.name == name)
.ok_or_else(|| IdeError::invalid(format!("No artifact named {name} in Project Structure › Artifacts")))?;
let (roots, jdk) = crate::ops::build::structure_inputs(root, settings, detected);
let war = base.join("artifact").join(format!(
"{}.war",
name.split(':').next().unwrap_or(name).replace(|c: char| !c.is_alphanumeric() && c != '-', "_")
));
let plan = compile::structure_war_plan(
root,
&settings.project_structure,
&ps,
&roots,
jdk.as_ref(),
&settings.languages.java.language_level,
@@ -278,7 +277,9 @@ pub async fn run_tomcat_artifacts(host: &Host, window: &str) -> IdeResult<Vec<id
let mut artifacts = ide_build::web::artifacts(&project.root, &model);
// Without a build tool, the Project Structure's WAR artifacts are built by the IDE.
if model.maven.is_none() && model.gradle.is_empty() {
artifacts.extend(project_web_artifacts(&settings));
let detected = project.detected_roots.read().clone();
let (ps, _, _) = crate::ops::build::structure_inputs(&project.root, &settings, &detected);
artifacts.extend(project_web_artifacts(&ps));
}
artifacts
})
+41 -2
Переглянути файл
@@ -338,6 +338,15 @@ pub fn env_wrapper(bin_dir: &Path, command: &str, target: &Path, env: &[(&str, &
}
pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResult<PathBuf> {
link_executable_with_runtime(bin_dir, command, target, None)
}
pub fn link_executable_with_runtime(
bin_dir: &Path,
command: &str,
target: &Path,
runtime: Option<&str>,
) -> IdeResult<PathBuf> {
fs::create_dir_all(bin_dir)?;
#[cfg(unix)]
{
@@ -347,7 +356,8 @@ pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResul
}
let quoted = target.to_string_lossy().replace('\'', r"'\''");
// A Node script without a shebang (e.g. js-debug's dapDebugServer.js) runs through `node`.
let runner = if target.extension().is_some_and(|e| e == "js") { "node " } else { "" };
let runner = runtime.or_else(|| target.extension().is_some_and(|e| e == "js").then_some("node"));
let runner = runner.map(|r| format!("{r} ")).unwrap_or_default();
fs::write(&link, format!("#!/bin/sh\nexec {runner}'{quoted}' \"$@\"\n"))?;
make_executable(&link)?;
make_executable(target)?;
@@ -356,7 +366,8 @@ pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResul
#[cfg(not(unix))]
{
let link = bin_dir.join(format!("{command}.cmd"));
let runner = if target.extension().is_some_and(|e| e == "js") { "node " } else { "" };
let runner = runtime.or_else(|| target.extension().is_some_and(|e| e == "js").then_some("node"));
let runner = runner.map(|r| format!("{r} ")).unwrap_or_default();
fs::write(&link, format!("@echo off\r\n{runner}\"{}\" %*\r\n", cmd_path(bin_dir, target)))?;
Ok(link)
}
@@ -510,6 +521,34 @@ mod tests {
assert!(dest.join("ok.txt").exists());
}
#[test]
fn unity_vsix_wrapper_preserves_managed_assemblies_and_uses_mono_on_unix() {
let tmp = tempfile::tempdir().unwrap();
let archive = tmp.path().join("unity.vsix");
zip_file(
&archive,
&[
("extension/bin/UnityDebug.exe", b"adapter", 0o644),
("extension/bin/UnityDebug.exe.config", b"runtime config", 0o644),
("extension/bin/Mono.Debugger.Soft.dll", b"dependency", 0o644),
],
);
let dest = tmp.path().join("install with spaces");
extract(&archive, ArchiveKind::Zip, &dest, "unity-debug", &CancellationToken::new()).unwrap();
let target = locate(&dest, &["UnityDebug.exe".into()]).unwrap();
let wrapper =
link_executable_with_runtime(&dest.join("bin"), "unity-debug", &target, cfg!(unix).then_some("mono"))
.unwrap();
let script = fs::read_to_string(wrapper).unwrap();
assert!(script.contains(&*target.to_string_lossy()));
#[cfg(unix)]
assert!(script.contains("exec mono '") && script.contains("\"$@\""));
#[cfg(windows)]
assert!(script.contains("\" %*") && !script.contains("mono "));
assert_eq!(fs::read(target.with_extension("exe.config")).unwrap(), b"runtime config");
assert_eq!(fs::read(target.parent().unwrap().join("Mono.Debugger.Soft.dll")).unwrap(), b"dependency");
}
#[test]
fn zip_symlinks_are_confined_to_the_destination() {
for target in ["../outside", "/tmp/outside", "a/../../outside"] {
+13 -1
Переглянути файл
@@ -1296,6 +1296,14 @@ impl Tools {
cancel: &CancellationToken,
) -> IdeResult<sources::Download> {
match source {
ReleaseSource::Fixed { version, url, sha256 } => Ok(sources::Download {
version: version.into(),
name: url.rsplit('/').next().unwrap_or("download").into(),
url: url.into(),
size: None,
sha256: Some(sha256.into()),
checksum_url: None,
}),
ReleaseSource::GitHub { repo } => match http.get_text(&sources::github_latest_url(repo), cancel) {
Ok(json) => sources::github_pick(&json, assets, self.platform),
Err(e) if e.kind == ErrorKind::Cancelled => Err(e),
@@ -1442,7 +1450,11 @@ impl Tools {
} else {
archive::make_executable(&target)?;
if self.exe_in(&bin, main).as_deref() != Some(target.as_path()) {
archive::link_executable(&bin, main, &target)?;
if spec.name == "unity-debug" && cfg!(unix) {
archive::link_executable_with_runtime(&bin, main, &target, Some("mono"))?;
} else {
archive::link_executable(&bin, main, &target)?;
}
}
}
self.write_manifest(spec.name, &Manifest { version: Some(dl.version.clone()), source: Some(dl.url.clone()) })
+28
Переглянути файл
@@ -20,6 +20,8 @@ pub enum ToolKind {
/// Where release archives come from.
#[derive(Clone, Copy, Debug)]
pub enum ReleaseSource {
/// One pinned archive, verified against its SHA-256 before extraction.
Fixed { version: &'static str, url: &'static str, sha256: &'static str },
/// Latest GitHub release of `owner/repo`; assets plus links in the release notes.
GitHub { repo: &'static str },
/// `api.releases.hashicorp.com` product.
@@ -80,6 +82,7 @@ impl Method {
Method::Release { source: ReleaseSource::EclipseJdtls, .. } => "Eclipse download",
Method::Release { source: ReleaseSource::OpenVsx { .. }, .. } => "Open VSX",
Method::Release { source: ReleaseSource::MavenCentral { .. }, .. } => "Maven Central",
Method::Release { source: ReleaseSource::Fixed { .. }, .. } => "Verified download",
Method::Release { .. } => "GitHub release",
}
}
@@ -131,6 +134,29 @@ const fn ver(cmd: &'static str) -> Option<(&'static str, &'static [&'static str]
pub const TYPESCRIPT: &str = "typescript@6";
pub static TOOLS: &[ToolSpec] = &[
ToolSpec {
name: "unity-debug",
display: "Unity Debugger",
kind: Debugger,
commands: &["unity-debug"],
method: Method::Release {
source: ReleaseSource::Fixed {
version: "3.0.1",
url: "https://github.com/Unity-Technologies/vscode-unity-debug/releases/download/Version-3.0.1/unity-debug-3.0.1.vsix",
sha256: "4fa00660e0b52b0413726f80962e7d3d6efd41ac6cfd4df39520cae4a8ba5bd0",
},
assets: &[any_arch(Mac, "*.vsix"), any_arch(Linux, "*.vsix"), any_arch(Windows, "*.vsix")],
locate: &["UnityDebug.exe"],
},
fallback: None,
version: V,
homepage: "https://github.com/Unity-Technologies/vscode-unity-debug",
needs: if cfg!(windows) {
&[]
} else {
&[("mono", "Mono is required to run the Unity debugger (https://www.mono-project.com)")]
},
},
ToolSpec {
name: "prettier",
display: "Prettier",
@@ -1164,6 +1190,8 @@ mod tests {
fn registry_names_match_language_configs() {
let langs = ide_language::LanguageRegistry::load(None).unwrap().all();
let mut known = std::collections::HashSet::new();
// The Unity debugger comes with Unity projects, apart from the C# debugger.
known.insert(("unity-debug".to_owned(), "unity-debug".to_owned()));
for l in &langs {
for s in &l.language_servers {
known.insert((s.name.clone(), s.command.clone()));
+18
Переглянути файл
@@ -49,6 +49,24 @@ fn find<'a>(list: &'a [ToolInfo], name: &str) -> &'a ToolInfo {
list.iter().find(|t| t.name == name).unwrap_or_else(|| panic!("{name} not listed"))
}
#[test]
fn unity_adapter_download_is_pinned_and_checksum_verified() {
let env = Env::new();
let tools = env.tools();
let spec = registry::find("unity-debug").unwrap();
let Method::Release { source, assets, locate } = spec.method else { panic!("expected release") };
// A fixed release resolves without a network request.
let curl = env.sys.join(if cfg!(windows) { "curl.exe" } else { "curl" });
fs::write(&curl, b"unused").unwrap();
archive::make_executable(&curl).unwrap();
let http = Http::new(env.sys.as_os_str()).unwrap();
let download = tools.resolve_release(&http, source, assets, &CancellationToken::new()).unwrap();
assert_eq!(download.version, "3.0.1");
assert!(download.url.starts_with("https://github.com/Unity-Technologies/vscode-unity-debug/releases/download/"));
assert_eq!(download.sha256.as_deref(), Some("4fa00660e0b52b0413726f80962e7d3d6efd41ac6cfd4df39520cae4a8ba5bd0"));
assert_eq!(locate, &["UnityDebug.exe"]);
}
#[test]
fn bundled_lombok_replaces_legacy_installs_on_every_platform_without_downloads() {
for os in [Os::Mac, Os::Linux, Os::Windows] {
+15
Переглянути файл
@@ -33,6 +33,7 @@ pub(crate) fn virtual_env_marker(dir: &Path) -> Option<&'static str> {
/// Build files whose changes can change the detected roots.
pub(crate) const BUILD_FILES: &[&str] = &[
"pom.xml",
".classpath",
"build.gradle",
"build.gradle.kts",
"settings.gradle",
@@ -238,6 +239,20 @@ fn module_roots(root: &Path, rel: &str, files: &[String], out: &mut Vec<SourceFo
}
}
// An Eclipse project without Maven or Gradle: its `.classpath` is the source model.
if has(".classpath")
&& !has("pom.xml")
&& !GRADLE_FILES.iter().any(|f| has(f))
&& let Some(cp) = super::eclipse::classpath(&dir)
{
for (sub, test) in &cp.sources {
add(sub, if *test { RootKind::Test } else { RootKind::Source }, ".classpath");
}
if let Some(output) = &cp.output {
add(output, RootKind::Excluded, ".classpath");
}
}
// Before `package.json`: a Laravel app's `tests/` is the PHP test root.
if has("composer.json")
&& let Ok(text) = std::fs::read_to_string(dir.join("composer.json"))
+193
Переглянути файл
@@ -0,0 +1,193 @@
//! Eclipse projects without Maven or Gradle: `.classpath` names the source folders (tests
//! by their `test` attribute), the output folder and the library jars; a Dynamic Web
//! Project's `.settings/org.eclipse.wst.common.component` names the web content folder.
use std::path::Path;
/// What `.classpath` declares, with project-relative `/`-separated paths.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct EclipseClasspath {
/// Source folders and whether they hold tests.
pub sources: Vec<(String, bool)>,
pub output: Option<String>,
/// Library jars or class folders (`kind="lib"`), project-relative or absolute.
pub libraries: Vec<String>,
}
/// The value of `name="…"` in a tag's text.
fn attribute(tag: &str, name: &str) -> Option<String> {
let mut rest = tag;
while let Some(at) = rest.find(name) {
let before = rest[..at].chars().last();
let after = &rest[at + name.len()..];
rest = after;
if before.is_some_and(|c| !c.is_whitespace()) {
continue;
}
let Some(after) = after.trim_start().strip_prefix('=') else { continue };
let after = after.trim_start();
let quote = after.chars().next().filter(|c| *c == '"' || *c == '\'')?;
let value = &after[1..];
let end = value.find(quote)?;
return Some(unescape(&value[..end]));
}
None
}
fn unescape(value: &str) -> String {
value.replace("&quot;", "\"").replace("&apos;", "'").replace("&lt;", "<").replace("&gt;", ">").replace("&amp;", "&")
}
/// Each element `<name …>…</name>` or `<name …/>` as (opening tag, inner text).
fn elements<'a>(text: &'a str, name: &str) -> Vec<(&'a str, &'a str)> {
let open = format!("<{name}");
let close = format!("</{name}>");
let mut out = Vec::new();
let mut rest = text;
while let Some(at) = rest.find(&open) {
let from = &rest[at..];
// `<classpathentry` must not match `<classpathentryX`.
if !from[open.len()..].starts_with(|c: char| c.is_whitespace() || c == '/' || c == '>') {
rest = &from[open.len()..];
continue;
}
let Some(end) = from.find('>') else { break };
let tag = &from[..=end];
if tag.ends_with("/>") {
out.push((tag, ""));
rest = &from[end + 1..];
} else {
let body = &from[end + 1..];
let stop = body.find(&close).unwrap_or(body.len());
out.push((tag, &body[..stop]));
rest = &body[stop..];
}
}
out
}
fn clean(path: &str) -> String {
let p = path.trim().replace('\\', "/");
let p = p.trim_start_matches("./").trim_end_matches('/');
p.to_owned()
}
pub fn parse_classpath(text: &str) -> EclipseClasspath {
let mut out = EclipseClasspath::default();
for (tag, body) in elements(text, "classpathentry") {
let (Some(kind), Some(path)) = (attribute(tag, "kind"), attribute(tag, "path")) else { continue };
let path = clean(&path);
match kind.as_str() {
// `/OtherProject` is a project reference, not a folder of this one.
"src" if !path.starts_with('/') && !path.is_empty() => {
let test = elements(body, "attribute").iter().any(|(a, _)| {
attribute(a, "name").as_deref() == Some("test") && attribute(a, "value").as_deref() == Some("true")
});
out.sources.push((path, test));
}
"output" if !path.is_empty() => out.output = Some(path),
"lib" if !path.is_empty() => out.libraries.push(path),
_ => {}
}
}
out
}
/// The project's `.classpath`, unless a Maven or Gradle build owns its model.
pub fn classpath(dir: &Path) -> Option<EclipseClasspath> {
if ["pom.xml", "build.gradle", "build.gradle.kts"].iter().any(|f| dir.join(f).is_file()) {
return None;
}
std::fs::read_to_string(dir.join(".classpath")).ok().map(|t| parse_classpath(&t))
}
/// The web content folder of a web project: the `wb-resource` deployed at `/`, else a
/// conventional `WebContent` / `WebRoot` / `web` / `src/main/webapp` holding `WEB-INF/web.xml`.
pub fn web_root(dir: &Path) -> Option<String> {
if let Ok(text) = std::fs::read_to_string(dir.join(".settings/org.eclipse.wst.common.component")) {
for (tag, _) in elements(&text, "wb-resource") {
if attribute(tag, "deploy-path").as_deref() == Some("/")
&& let Some(source) = attribute(tag, "source-path")
{
let source = clean(source.trim_start_matches('/'));
if dir.join(&source).is_dir() {
return Some(source);
}
}
}
}
["WebContent", "WebRoot", "web", "src/main/webapp"]
.into_iter()
.find(|d| dir.join(d).join("WEB-INF/web.xml").is_file())
.map(str::to_owned)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reads_sources_tests_output_and_libraries() {
let cp = parse_classpath(
r#"<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" output="bin/test" path="test">
<attributes>
<attribute name="test" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="src" path="/OtherProject"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry kind="lib" path="WebContent/WEB-INF/lib/commons-lang.jar"/>
<classpathentry kind='lib' path='lib\mail.jar' sourcepath="lib/mail-src.zip"/>
<classpathentry kind="output" path="build/classes"/>
</classpath>"#,
);
assert_eq!(cp.sources, [("src".to_owned(), false), ("test".to_owned(), true)]);
assert_eq!(cp.output.as_deref(), Some("build/classes"));
assert_eq!(cp.libraries, ["WebContent/WEB-INF/lib/commons-lang.jar", "lib/mail.jar"]);
}
#[test]
fn finds_the_web_content_folder() {
let dir = tempfile::tempdir().unwrap();
std::fs::create_dir_all(dir.path().join("site/WEB-INF")).unwrap();
std::fs::create_dir_all(dir.path().join(".settings")).unwrap();
std::fs::write(
dir.path().join(".settings/org.eclipse.wst.common.component"),
r#"<project-modules><wb-module deploy-name="shop">
<wb-resource deploy-path="/WEB-INF/classes" source-path="/src"/>
<wb-resource deploy-path="/" source-path="/site" tag="defaultRootSource"/>
</wb-module></project-modules>"#,
)
.unwrap();
assert_eq!(web_root(dir.path()).as_deref(), Some("site"));
let plain = tempfile::tempdir().unwrap();
std::fs::create_dir_all(plain.path().join("WebRoot/WEB-INF")).unwrap();
assert_eq!(web_root(plain.path()), None);
std::fs::write(plain.path().join("WebRoot/WEB-INF/web.xml"), "<web-app/>").unwrap();
assert_eq!(web_root(plain.path()).as_deref(), Some("WebRoot"));
}
#[test]
fn detects_the_roots_of_an_eclipse_project() {
use super::super::{RootKind, detect};
let dir = tempfile::tempdir().unwrap();
for d in ["src", "test", "bin"] {
std::fs::create_dir_all(dir.path().join(d)).unwrap();
}
std::fs::write(
dir.path().join(".classpath"),
r#"<classpath><classpathentry kind="src" path="src"/><classpathentry kind="src" path="test"><attributes><attribute name="test" value="true"/></attributes></classpathentry><classpathentry kind="output" path="bin"/></classpath>"#,
)
.unwrap();
let roots: Vec<(String, RootKind)> = detect(dir.path()).into_iter().map(|r| (r.path, r.kind)).collect();
assert_eq!(
roots,
[("bin".into(), RootKind::Excluded), ("src".into(), RootKind::Source), ("test".into(), RootKind::Test)]
);
// A Maven build owns the model even with a stale `.classpath` next to it.
std::fs::write(dir.path().join("pom.xml"), "<project/>").unwrap();
assert!(detect(dir.path()).iter().all(|r| r.detected_from.as_deref() != Some(".classpath")));
}
}
+1
Переглянути файл
@@ -6,6 +6,7 @@
//! project-relative and `/`-separated; `""` is the project root itself.
mod detect;
pub mod eclipse;
pub(crate) use detect::{BUILD_FILES, virtual_env_marker};
mod gradle;
mod java;
+21 -1
Переглянути файл
@@ -30,12 +30,14 @@ pub enum SettingsScope {
/// Settings a project's own file can't hold: the IDE's MCP server, imported color schemes, and
/// what agents may do without asking (commands run without asking, the modes new tasks start in,
/// whether new tasks ask for approvals).
const USER_ONLY: [&[&str]; 5] = [
const USER_ONLY: [&[&str]; 6] = [
&["mcpServer"],
&["editor", "customSchemes"],
&["agentSecurity", "allowedCommands"],
&["agents", "defaults"],
&["agents", "newTaskApprovals"],
// OS notification centre: machine-local; projects must not enable/disable.
&["notifications", "systemNotifications"],
];
/// The [`USER_ONLY`] setting that writing `value` at `key` would set, as a dotted key.
@@ -1219,4 +1221,22 @@ mod tests {
std::fs::write(project.join(".openidea/settings.toml"), "[agents]\nnewTaskApprovals = \"bypass\"\n").unwrap();
assert_eq!(settings.reload().agents.new_task_approvals, NewTaskApprovals::Ask);
}
#[test]
fn system_notifications_are_a_user_setting() {
let tmp = tempfile::tempdir().unwrap();
let config = tmp.path().join("config");
let project = tmp.path().join("project");
std::fs::create_dir_all(project.join(".openidea")).unwrap();
std::fs::write(project.join(".openidea/settings.toml"), "[notifications]\nsystemNotifications = false\n")
.unwrap();
let settings = SettingsStore::load(&config, Some(&project));
assert!(settings.effective().notifications.system_notifications);
assert!(settings.set(SettingsScope::Project, "notifications.systemNotifications", json!(false)).is_err());
let s = settings.set(SettingsScope::Global, "notifications.systemNotifications", json!(false)).unwrap();
assert!(!s.notifications.system_notifications);
std::fs::write(project.join(".openidea/settings.toml"), "[notifications]\nsystemNotifications = true\n")
.unwrap();
assert!(!settings.reload().notifications.system_notifications);
}
}
+7 -6
Переглянути файл
@@ -152,12 +152,13 @@ Sub-tables such as `[editor.general]`, `[editor.appearance]`, `[editor.completio
### `[notifications]`
| Key | Default | Description |
| --------------------------- | ----------- | ------------------------------------------------------------ |
| `balloons` | `true` | **Display balloon notifications**. |
| `sound` | `false` | **Play sound**. |
| `groups.<group-id>.display` | `"balloon"` | Popup type per group: `balloon`, `sticky` or `none`. |
| `groups.<group-id>.log` | `true` | Also list the notification in the Notifications tool window. |
| Key | Default | Description |
| --------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `balloons` | `true` | **Display balloon notifications**. |
| `sound` | `false` | **Play sound**. |
| `systemNotifications` | `true` | **Enable system notifications**. When a balloon is shown and no OpenIDEA window is focused, the same title and text also go to the OS notification centre. On by default; client/local only. Click focuses the window that raised the toast; balloon actions stay in the IDE. **Windows:** a click is reported only while the toast is on screen, not after it moves to Action Center. Desktop `permission_state` always reports Granted without an OS prompt — that is not proof Do Not Disturb or system notification settings allow delivery. |
| `groups.<group-id>.display` | `"balloon"` | Popup type per group: `balloon`, `sticky` or `none`. |
| `groups.<group-id>.log` | `true` | Also list the notification in the Notifications tool window. |
### `[terminal]`
+7 -6
Переглянути файл
@@ -152,12 +152,13 @@ exclude = ["**/.git", "**/node_modules", "**/target", "**/dist"]
### `[notifications]`
| 键 | 默认值 | 说明 |
| --------------------------- | ----------- | --------------------------------------------------- |
| `balloons` | `true` | **显示气球通知**。 |
| `sound` | `false` | **播放声音**。 |
| `groups.<group-id>.display` | `"balloon"` | 每个分组的弹出方式:`balloon`、`sticky` 或 `none`。 |
| `groups.<group-id>.log` | `true` | 同时在通知工具窗口中列出。 |
| 键 | 默认值 | 说明 |
| --------------------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `balloons` | `true` | **显示气球通知**。 |
| `sound` | `false` | **播放声音**。 |
| `systemNotifications` | `true` | **启用系统通知**。气球通知显示且没有任何 OpenIDEA 窗口处于焦点时,相同的标题和正文也会发到操作系统通知中心。默认开启;仅客户端/本机设置。点击会聚焦发出该通知的窗口;气球操作仍只在 IDE 内。**Windows:**仅在 toast 仍显示在屏幕上时可收到点击,进入操作中心后不再触发。桌面端 `permission_state` 始终返回 Granted 且不会弹出系统授权——这并不表示勿扰模式或系统通知设置允许显示。 |
| `groups.<group-id>.display` | `"balloon"` | 每个分组的弹出方式:`balloon`、`sticky` 或 `none`。 |
| `groups.<group-id>.log` | `true` | 同时在通知工具窗口中列出。 |
### `[terminal]`
+1
Переглянути файл
@@ -16,6 +16,7 @@ dunce.workspace = true
[dependencies]
tauri = { version = "2", features = [] }
tauri-plugin-opener = "2"
tauri-plugin-notification = "2.8.1"
tauri-plugin-dialog = { version = "2", default-features = false, features = ["xdg-portal"] }
tauri-plugin-mcp-bridge = "0.13"
tauri-plugin-window-state = "2"
+1
Переглянути файл
@@ -16,6 +16,7 @@
"core:webview:allow-set-webview-background-color",
"opener:default",
"opener:allow-reveal-item-in-dir",
"notification:default",
"dialog:default",
"core:window:allow-destroy",
"core:window:allow-close",
+9
Переглянути файл
@@ -348,6 +348,15 @@ pub async fn debug_free_port(window: Window, state: State<'_, AppState>) -> IdeR
ide_host::ops::debug::debug_free_port(&state.host, window.label()).await
}
#[tauri::command]
#[specta::specta]
pub async fn debug_unity_processes(
window: tauri::Window,
state: State<'_, AppState>,
) -> IdeResult<Vec<attach::AttachableProcess>> {
ide_host::ops::debug::debug_unity_processes(&state.host, window.label()).await
}
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
#[tauri::command]
+3
Переглянути файл
@@ -35,6 +35,7 @@ pub mod lsp;
pub mod mcp;
pub mod nav;
pub mod notebook;
pub mod notification;
pub mod perf;
pub mod plugin;
pub mod profiler;
@@ -199,6 +200,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
clipboard::clipboard_has_image,
clipboard::clipboard_image,
clipboard::clipboard_set_file_list,
notification::show_system_notification,
fonts::system_font_families,
doc::doc_open,
doc::doc_open_virtual,
@@ -551,6 +553,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
debug::debug_data_breakpoint_info,
debug::debug_attachable_processes,
debug::debug_free_port,
debug::debug_unity_processes,
debug::debug_listen_for_jvm,
debug::debug_redefine_classes,
debug::debug_jvm_memory_classes,
+12
Переглянути файл
@@ -0,0 +1,12 @@
//! IPC for OS notification centre toasts.
use ide_core::IdeResult;
use tauri::{AppHandle, Window};
/// When a balloon is shown and OpenIDEA is unfocused, mirror it to the OS.
#[tauri::command]
#[specta::specta]
pub fn show_system_notification(app: AppHandle, window: Window, title: String, body: String) -> IdeResult<()> {
crate::system_notifications::show(&app, window.label(), title, body);
Ok(())
}
+6 -1
Переглянути файл
@@ -26,6 +26,7 @@ mod relaunch;
mod remote_container;
mod remote_dev;
mod remote_wsl;
mod system_notifications;
mod state;
mod theme_frame;
@@ -121,7 +122,10 @@ pub fn run() {
// Install before window-state restores maximized geometry during window creation.
#[cfg(windows)]
let app = app.plugin(window_work_area::init());
let app = app.plugin(tauri_plugin_opener::init()).plugin(tauri_plugin_dialog::init());
let app = app
.plugin(tauri_plugin_opener::init())
.plugin(tauri_plugin_notification::init())
.plugin(tauri_plugin_dialog::init());
#[cfg(target_os = "linux")]
let app = app.plugin(linux_window_state::plugin());
#[cfg(not(target_os = "linux"))]
@@ -220,6 +224,7 @@ pub fn run() {
windows::report_cli_error(app.handle(), error);
}
app.manage(application_focus::ApplicationFocus::default());
system_notifications::init(app.handle());
#[cfg(target_os = "macos")]
macos::intercept_system_quit(app.handle());
#[cfg(target_os = "macos")]
+1
Переглянути файл
@@ -179,6 +179,7 @@ impl AppState {
/// Called on the event-loop thread (window destruction, the `close_project`
/// command), so it must not wait for the project's workers to shut down.
pub fn close_project(&self, window: &str) {
crate::system_notifications::clear_window(window);
self.remote_dev.disconnect(window);
self.host.close_project_detached(window);
}
+150
Переглянути файл
@@ -0,0 +1,150 @@
//! OS notification centre toasts for in-IDE balloons while OpenIDEA is unfocused.
//!
//! Driven by `show_system_notification` from the notification store. Honour
//! global `[notifications].systemNotifications`; suppressed while any window is
//! active. Click focuses the window that raised the toast — balloon actions stay
//! in the IDE.
use parking_lot::Mutex;
use std::collections::HashMap;
use std::sync::LazyLock;
use std::sync::atomic::{AtomicBool, AtomicI32, Ordering};
use tauri::{AppHandle, Manager};
use tauri_plugin_notification::{NotificationExt, PermissionState};
const MAX_TARGETS: usize = 64;
struct State {
ready: AtomicBool,
next_id: AtomicI32,
/// Native notification id → owning window label.
targets: Mutex<HashMap<i32, String>>,
}
impl State {
fn new() -> Self {
Self { ready: AtomicBool::new(false), next_id: AtomicI32::new(1), targets: Mutex::new(HashMap::new()) }
}
fn put_target(&self, id: i32, window: String) {
let mut targets = self.targets.lock();
targets.insert(id, window);
while targets.len() > MAX_TARGETS {
let oldest = targets.keys().copied().min();
if let Some(oldest) = oldest {
targets.remove(&oldest);
} else {
break;
}
}
}
fn take_target(&self, id: i32) -> Option<String> {
self.targets.lock().remove(&id)
}
fn clear_window(&self, window: &str) {
self.targets.lock().retain(|_, w| w != window);
}
}
static STATE: LazyLock<State> = LazyLock::new(State::new);
/// Registers the notification plugin's activation handler once.
pub fn init(app: &AppHandle) {
if STATE.ready.swap(true, Ordering::AcqRel) {
return;
}
let handle = app.clone();
if let Err(e) = app.notification().on_action(move |performed| {
if performed.action_id() != "tap" {
return;
}
let Some(n) = performed.notification() else { return };
activate(&handle, n.id());
}) {
tracing::warn!("system notifications: cannot register action handler: {e}");
STATE.ready.store(false, Ordering::Release);
}
}
/// Project closed or window replaced: drop click targets for that owner.
pub fn clear_window(window: &str) {
STATE.clear_window(window);
}
/// Show an OS toast when the setting is on and no OpenIDEA window is focused.
pub fn show(app: &AppHandle, window: &str, title: String, body: String) {
let owner = crate::state::AppState::owner_window(window).to_owned();
let app = app.clone();
let _ = app.clone().run_on_main_thread(move || deliver(&app, &owner, &title, &body));
}
fn deliver(app: &AppHandle, window: &str, title: &str, body: &str) {
let Some(state) = app.try_state::<crate::state::AppState>() else { return };
let settings = state.host.global_settings.effective();
if !settings.notifications.system_notifications {
return;
}
if crate::application_focus::application_active(app) {
return;
}
init(app);
if !STATE.ready.load(Ordering::Acquire) {
return;
}
// Desktop always reports Granted without an OS prompt (not proof of visible delivery).
let granted = app
.notification()
.permission_state()
.ok()
.or_else(|| app.notification().request_permission().ok())
.is_some_and(|s| s == PermissionState::Granted);
if !granted {
return;
}
let id = STATE.next_id.fetch_add(1, Ordering::Relaxed);
STATE.put_target(id, window.to_owned());
let mut builder = app.notification().builder().id(id).title(title).body(body);
if settings.notifications.sound {
builder = builder.sound("default");
}
if let Err(e) = builder.show() {
tracing::debug!("system notification not shown: {e}");
STATE.take_target(id);
}
}
fn activate(app: &AppHandle, id: i32) {
let Some(window_label) = STATE.take_target(id) else { return };
let app = app.clone();
let _ = app.clone().run_on_main_thread(move || {
let Some(window) = app.get_webview_window(&window_label) else { return };
let _ = window.unminimize();
let _ = window.show();
let _ = window.set_focus();
});
}
#[cfg(test)]
mod tests {
use super::*;
use ide_core::settings::NotificationSettings;
#[test]
fn settings_default_on() {
assert!(NotificationSettings::default().system_notifications);
}
#[test]
fn clear_window_drops_targets() {
let state = State::new();
state.put_target(1, "w1".into());
state.put_target(2, "w2".into());
state.clear_window("w1");
assert!(state.take_target(1).is_none());
assert_eq!(state.take_target(2).as_deref(), Some("w2"));
}
}
+2
Переглянути файл
@@ -165,6 +165,7 @@ debug_step_in_target trusted project_host bin
debug_step_in_targets trusted project_host bindings async
debug_stop always project_host bindings async
debug_threads trusted project_host bindings async
debug_unity_processes trusted project_host bindings async
debug_variables trusted project_host bindings async
dependency_versions trusted project_host bindings async
deploy_compare trusted project_host bindings async
@@ -535,6 +536,7 @@ settings_list_jetbrains_ides always desktop bin
settings_read_jetbrains always desktop bindings async
settings_removed_theme always project_host bindings sync
settings_set always project_host bindings sync
show_system_notification trusted desktop bindings sync
spell_check always project_host bindings async
spell_suggest always project_host bindings async
spring_route_sources trusted desktop bindings sync
+40 -2
Переглянути файл
@@ -331,6 +331,8 @@ export const commands = {
* false when the clipboard stayed busy; the caller keeps working either way.
*/
clipboardSetFileList: (paths: string[]) => typedError<boolean, IdeError>(__TAURI_INVOKE("clipboard_set_file_list", { paths })),
/** When a balloon is shown and OpenIDEA is unfocused, mirror it to the OS. */
showSystemNotification: (title: string, body: string) => typedError<null, IdeError>(__TAURI_INVOKE("show_system_notification", { title, body })),
/**
* Every installed family, sorted, each flagged monospaced or not. Read on
* first use (off the command threads), cached, and re-queried on `refresh`.
@@ -1335,6 +1337,7 @@ export const commands = {
debugAttachableProcesses: () => typedError<AttachableProcess[], IdeError>(__TAURI_INVOKE("debug_attachable_processes")),
/** A loopback port that is free right now, for a debug agent the launch line starts. */
debugFreePort: () => typedError<number, IdeError>(__TAURI_INVOKE("debug_free_port")),
debugUnityProcesses: () => typedError<AttachableProcess[], IdeError>(__TAURI_INVOKE("debug_unity_processes")),
/**
* Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
* JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
@@ -1892,6 +1895,9 @@ export type AgentAcceptSkipped = {
reason: string,
};
/** Why a task needs the user's attention (native / in-app notify). */
export type AgentAttentionReason = "finished" | "input" | "failed";
/** A task the agent runs in the background while the conversation goes on. */
export type AgentBackgroundTask = {
id: string,
@@ -2098,7 +2104,9 @@ export type AgentEvent =
/** A model lookup started or completed, including unsuccessful lookups. */
{ type: "modelCatalog"; catalog: AgentModelCatalog } |
/** The installed or configured agent providers changed. */
{ type: "providers" };
{ type: "providers" } |
/** The task needs attention once (finished turn, explicit input, or failure). */
{ type: "attention"; task: string; eventId: string; reason: AgentAttentionReason };
/** A form the agent asks the user to fill in (ACP `elicitation/create`, form mode). */
export type AgentForm = {
@@ -2730,7 +2738,7 @@ export type AskpassKind =
/** Yes / no (an unknown host key); answered with `yes` or `no`. */
"confirm";
export type AttachKind = "java" | "node" | "python" | "dotnet" | "go" | "native";
export type AttachKind = "unity" | "java" | "node" | "python" | "dotnet" | "go" | "native";
export type AttachableProcess = {
pid: number,
@@ -3854,6 +3862,20 @@ export type DataSource_Serialize = {
pluginSourceId?: string | null,
};
/** Database settings: Query Execution and SQL Resolution Scopes. */
export type DatabaseSettings = {
/**
* A console's result sets show under the statements that produced them, in the editor,
* instead of in the Services view's result tabs.
*/
inEditorResults?: boolean,
/**
* Languages & Frameworks › SQL Resolution Scopes: the data source SQL in a file or folder
* resolves against (completion, inspections, navigation), most specific path first.
*/
resolutionScopes?: SqlResolutionScope[],
};
/** System Settings › Date Formats (Git log, Local History, blame). */
export type DateFormatSettings = {
/** Use `pattern` / `use24_hour` instead of the system locale's format. */
@@ -7957,6 +7979,8 @@ export type NotificationLevel = "info" | "warning" | "error";
export type NotificationSettings = {
balloons?: boolean,
sound?: boolean,
/** Mirror balloon notifications to the OS when no OpenIDEA window is focused. */
systemNotifications?: boolean,
/** Group id → display; groups not listed use their default. */
groups?: { [key in string]: NotificationGroupSettings },
};
@@ -9928,6 +9952,8 @@ export type Settings_Deserialize = {
scopes?: NamedScope[],
/** Appearance & Behavior › File Colors. */
fileColors?: FileColorSettings,
/** Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes. */
database?: DatabaseSettings,
/** Plugin settings (`[contributes.settings]`): plugin id → its values by key. */
plugins?: { [key in string]: { [key in string]: unknown } },
};
@@ -9998,6 +10024,8 @@ export type Settings_Serialize = {
scopes: NamedScope[],
/** Appearance & Behavior › File Colors. */
fileColors: FileColorSettings,
/** Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes. */
database: DatabaseSettings,
/** Plugin settings (`[contributes.settings]`): plugin id → its values by key. */
plugins: { [key in string]: { [key in string]: unknown } },
};
@@ -10146,6 +10174,16 @@ export type SpellingSettings = {
customDictionaries?: string[],
};
/** One row of SQL Resolution Scopes. */
export type SqlResolutionScope = {
/** Project-relative file or folder, `/`-separated; empty for the whole project. */
path?: string,
/** Data source id. */
dataSource?: string,
/** Schema unqualified names resolve in; empty for the data source's default. */
schema?: string,
};
export type SqlStatement = {
/**
* UTF-16 offsets of the statement text (whitespace trimmed, `;` excluded except
-11
Переглянути файл
@@ -35,7 +35,6 @@ import {
import {
age,
appendEntry,
attentionChange,
branchLabel,
entriesKey,
findSubagent,
@@ -447,16 +446,6 @@ describe("agents model", () => {
expect(appendEntry([u, a], 2, 0, "x")).toBeNull();
});
it("notifies on finish, failure and questions only", () => {
expect(attentionChange("running", "ready")).toBe("finished");
expect(attentionChange("running", "failed")).toBe("failed");
expect(attentionChange("running", "limited")).toBe("failed");
expect(attentionChange("running", "needsInput")).toBe("input");
expect(attentionChange("needsInput", "running")).toBeNull();
expect(attentionChange("ready", "archived")).toBeNull();
expect(attentionChange(undefined, "ready")).toBeNull();
});
it("finds subagent cards and keys their conversations apart", () => {
const card: SubagentEntry = {
type: "subagent",
-13
Переглянути файл
@@ -242,16 +242,3 @@ export function age(ms: number, now = Date.now()): string {
if (h < 24) return `${h}h`;
return `${Math.round(h / 24)}d`;
}
/** The status change worth a notification, if any. */
export function attentionChange(
prev: AgentStatus | undefined,
next: AgentStatus,
): "finished" | "failed" | "input" | null {
if (prev === next || prev === undefined) return null;
if (next === "needsInput") return "input";
if (!isBusy(prev)) return null;
if (next === "ready") return "finished";
if (next === "failed" || next === "limited") return "failed";
return null;
}
+19 -16
Переглянути файл
@@ -53,7 +53,6 @@ import {
SESSION_KIND,
TOOL_WINDOW,
appendEntry,
attentionChange,
entriesKey,
isBusy,
sessionKey,
@@ -553,14 +552,17 @@ function onEvent(e: AgentEvent) {
useAgents.setState({ tasks: new Map(s.tasks).set(e.task.id, e.task) });
if (prev && (prev.title !== e.task.title || prev.status !== e.task.status)) notifyTabTitlesChanged();
if (e.task.status === "archived") setUnread(e.task.id, false);
else if (attentionChange(prev?.status, e.task.status)) markUnread(e.task.id);
notifyChange(prev, e.task);
if (prev?.status !== e.task.status && !isBusy(e.task.status)) {
void refreshChanges(e.task.id);
void refreshProviders();
}
break;
}
case "attention": {
markUnread(e.task);
notifyAttention(e.task, e.reason);
break;
}
case "removed": {
const tasks = new Map(s.tasks);
tasks.delete(e.id);
@@ -633,27 +635,28 @@ function onEvent(e: AgentEvent) {
}
}
function notifyChange(prev: AgentTask | undefined, task: AgentTask) {
const change = attentionChange(prev?.status, task.status);
if (!change) return;
if (viewing(task.id)) return;
/** In-app balloon for an Attention event; OS delivery goes through the general balloon path. */
function notifyAttention(taskId: string, reason: "finished" | "input" | "failed") {
if (viewing(taskId)) return;
const task = useAgents.getState().tasks.get(taskId);
const title = task?.title ?? "Agent";
const body =
change === "input"
reason === "input"
? "Waiting for your answer"
: change === "failed"
? (task.error ?? "The agent stopped")
: reason === "failed"
? (task?.error ?? "The agent stopped")
: "Finished";
notifications().notify({
level: change === "failed" ? "error" : "info",
title: task.title,
level: reason === "failed" ? "error" : "info",
title,
body,
key: `agent:${task.id}`,
key: `agent:${taskId}`,
group: "tools",
sticky: change !== "finished",
sticky: reason !== "finished",
actions: [
{
label: change === "finished" ? "Review" : "Open",
run: () => openTask(task.id),
label: reason === "finished" ? "Review" : "Open",
run: () => openTask(taskId),
},
],
});
+15 -2
Переглянути файл
@@ -163,16 +163,28 @@ describe("agent unread activity", () => {
expect([...useAgents.getState().unread]).toEqual(["one"]);
});
it.each(["ready", "needsInput", "failed", "limited"] as const)("marks background %s transitions unread", (status) => {
it.each([
["finished", "ready"],
["input", "needsInput"],
["failed", "failed"],
["failed", "limited"],
] as const)("marks background attention %s unread", (reason, status) => {
emit({ type: "task", task: task("one", status) });
emit({ type: "attention", task: "one", eventId: `one:${reason}:1`, reason });
expect(useAgents.getState().unread.has("one")).toBe(true);
expect(backend.notify).toHaveBeenCalledTimes(1);
show();
emit({ type: "task", task: task("one", status) });
emit({ type: "attention", task: "one", eventId: `one:${reason}:2`, reason });
expect(useAgents.getState().unread.size).toBe(0);
expect(backend.notify).toHaveBeenCalledTimes(1);
});
it("does not notify from status alone once Attention exists", () => {
emit({ type: "task", task: task("one", "ready") });
expect(backend.notify).not.toHaveBeenCalled();
expect(useAgents.getState().unread.has("one")).toBe(false);
});
it("keeps the latest usage limits per provider without marking anything unread", () => {
const fiveHour = (usedPercent: number) => [{ window: "five_hour", usedPercent, resetsMs: null }];
emit({ type: "limits", provider: "claude", limits: fiveHour(10) });
@@ -258,6 +270,7 @@ describe("agent unread activity", () => {
describe("agent unread indicators", () => {
it("shows a dot on the task and a clickable status count even when all tasks are idle", () => {
emit({ type: "task", task: task("one", "ready") });
emit({ type: "attention", task: "one", eventId: "one:finished:1", reason: "finished" });
render(
<>
<AgentsView />
+30
Переглянути файл
@@ -1407,3 +1407,33 @@
color: inherit;
cursor: default;
}
/* In-Editor Results: a result set under its statement in the console. */
:global(.cm-openidea-db-inline) {
padding: var(--space-1) 0 var(--space-2);
cursor: default;
}
.inlineResult {
position: relative;
display: flex;
flex-direction: column;
max-width: 100%;
border: 1px solid var(--border);
border-radius: var(--radius-control);
overflow: hidden;
background: var(--bg-editor);
font-family: var(--font-ui);
font-size: var(--fs-ui);
line-height: normal;
white-space: normal;
}
.inlineResult > :first-child {
flex: 1;
min-height: 0;
}
.inlineResize {
position: absolute;
inset: auto 0 0;
height: 5px;
cursor: row-resize;
}
+4 -2
Переглянути файл
@@ -254,7 +254,8 @@ function setSubmittingResult(result: DbQueryResult, on: boolean) {
notifyResults();
}
function Result({ tab }: { tab: ResultTab }) {
/** A result set's toolbar, grid and pager; `onClose` makes it an in-editor result (closed in place, not pinned). */
export function Result({ tab, onClose }: { tab: ResultTab; onClose?: () => void }) {
const [view, setView] = useState<"table" | "chart">("table");
const [panel, setPanel] = useState<DataPanel | null>(null);
const [searchOpen, setSearchOpen] = useState(false);
@@ -516,7 +517,7 @@ function Result({ tab }: { tab: ResultTab }) {
disabled={busy}
onClick={() => void rerunResult(tab.id)}
/>
<PinButton tab={tab} />
{!onClose && <PinButton tab={tab} />}
{view === "table" && (
<IconButton
icon="search"
@@ -568,6 +569,7 @@ function Result({ tab }: { tab: ResultTab }) {
onClick={(e) => showExport({ x: e.clientX, y: e.clientY })}
/>
{view === "table" && <PanelToggle panel={panel} onChange={setPanel} />}
{onClose && <IconButton icon="close" title="Close" onClick={onClose} />}
</Toolbar>
{view === "chart" ? (
<div className={styles.fill}>
+37
Переглянути файл
@@ -0,0 +1,37 @@
.page {
display: flex;
flex-direction: column;
gap: var(--space-2);
color: var(--fg);
font-size: var(--fs-ui);
}
.intro,
.hint {
margin: 0;
color: var(--fg-muted);
}
.list {
display: flex;
flex-direction: column;
border: 1px solid var(--border-strong);
border-radius: var(--radius-small);
padding: var(--space-0-5) 0;
}
.head,
.row {
display: grid;
grid-template-columns: minmax(160px, 2fr) minmax(140px, 1.5fr) minmax(100px, 1fr) 24px;
align-items: center;
gap: var(--space-2);
min-height: 30px;
padding: 0 var(--space-2);
}
.head {
min-height: 24px;
color: var(--fg-muted);
border-bottom: 1px solid var(--border);
}
.project {
padding-left: var(--space-1);
font-weight: 600;
}
+144
Переглянути файл
@@ -0,0 +1,144 @@
/**
* Languages & Frameworks › SQL Resolution Scopes: which data source (and schema) SQL in a
* folder or file resolves against — completion, inspections, navigation and running
* consoles there. The project row applies wherever no folder or file row does.
*/
import { useEffect, useState } from "react";
import { call, commands, type DataSource } from "@/platform/ipc";
import { tx } from "@/platform/i18n";
import { IconButton, Input, Select, T, type SelectOption } from "@/ui";
import { useSettingsForm } from "@/workbench/contributions";
import { scopePath, validateResolutionScopes, type SqlResolutionScope } from "./resolutionScopes";
import styles from "./SqlScopesPage.module.css";
const KEY = "database.resolutionScopes";
const NONE = "";
/** An example path, the same in every language. */
const PATH_EXAMPLE = "src/main/resources/mapper";
function useDataSources(): DataSource[] | null {
const [sources, setSources] = useState<DataSource[] | null>(null);
useEffect(() => {
let stale = false;
call(commands.dbSources())
.then((list) => !stale && setSources(list))
.catch(() => !stale && setSources([]));
return () => {
stale = true;
};
}, []);
return sources;
}
export function SqlScopesPage() {
const form = useSettingsForm();
const scopes = validateResolutionScopes(form.useValue(KEY));
const sources = useDataSources();
const set = (next: SqlResolutionScope[]) => form.set(KEY, next);
const options: SelectOption[] = [
{ value: NONE, label: tx("<none>") },
...(sources ?? []).map((s) => ({ value: s.id ?? "", label: s.name ?? s.id ?? "", icon: "database" })),
];
const sourceOptions = (current: string) =>
current && !options.some((o) => o.value === current)
? [...options, { value: current, label: tx`${current} (missing)` }]
: options;
const projectIndex = scopes.findIndex((s) => !s.path);
const project = scopes[projectIndex];
const rows = scopes.map((scope, index) => ({ scope, index })).filter(({ index }) => index !== projectIndex);
const empty = (): SqlResolutionScope => ({ path: "", dataSource: NONE, schema: "" });
const patch = (index: number, p: Partial<SqlResolutionScope>) =>
set(scopes.map((s, i) => (i === index ? { ...s, ...p } : s)));
const setProject = (p: Partial<SqlResolutionScope>) =>
project ? patch(projectIndex, p) : set([{ ...empty(), ...p }, ...scopes]);
return (
<div className={styles.page}>
<p className={styles.intro}>
<T>
SQL in these folders and files resolves against the data source: completion, inspections and navigation use
its tables, and query consoles run on it unless another data source is picked in their toolbar.
</T>
</p>
<div className={styles.list} role="table" aria-label={tx("SQL Resolution Scopes")}>
<div className={styles.head} role="row">
<span role="columnheader">
<T>Path</T>
</span>
<span role="columnheader">
<T>Data Source</T>
</span>
<span role="columnheader">
<T>Schema</T>
</span>
<span />
</div>
<div className={styles.row} role="row">
<span className={styles.project} role="cell">
<T>Project</T>
</span>
<Select
value={project?.dataSource ?? NONE}
options={sourceOptions(project?.dataSource ?? NONE)}
onChange={(dataSource) => setProject({ dataSource })}
aria-label={tx("Project data source")}
/>
<Input
mono
value={project?.schema ?? ""}
placeholder={tx("Default")}
onChange={(e) => setProject({ schema: e.target.value })}
aria-label={tx("Project schema")}
/>
<span />
</div>
{rows.map(({ scope, index }) => (
<div key={index} className={styles.row} role="row">
<Input
mono
value={scope.path}
placeholder={PATH_EXAMPLE}
invalid={!scopePath(scope.path)}
onChange={(e) => patch(index, { path: e.target.value })}
aria-label={tx("Path")}
/>
<Select
value={scope.dataSource}
options={sourceOptions(scope.dataSource)}
onChange={(dataSource) => patch(index, { dataSource })}
aria-label={tx("Data source")}
/>
<Input
mono
value={scope.schema}
placeholder={tx("Default")}
onChange={(e) => patch(index, { schema: e.target.value })}
aria-label={tx("Schema")}
/>
<IconButton
icon="trash"
size="small"
title="Remove"
onClick={() => set(scopes.filter((_, i) => i !== index))}
/>
</div>
))}
</div>
<div>
<IconButton
icon="plus"
size="small"
title="Add Folder or File"
// The first row without a path is the project's: keep one ahead of the new row.
onClick={() => set([...(project ? [] : [empty()]), ...scopes, empty()])}
/>
</div>
<p className={styles.hint}>
<T>Paths are relative to the project root. The deepest folder or file that contains a file applies to it.</T>
</p>
</div>
);
}
+225 -2
Переглянути файл
@@ -39,13 +39,14 @@ import {
type Panel,
type Tooltip,
} from "@codemirror/view";
import { useEffect, useMemo, useState } from "react";
import { useEffect, useMemo, useRef, useState, type PointerEvent } from "react";
import { createRoot } from "react-dom/client";
import type { EditorDocContext } from "@/editor/api";
import { iconNode } from "@/ui/iconNode";
import { call, commands, type DbDriver, type DbSessionContext, type DbStatementOutcome } from "@/platform/ipc";
import { shortcutLabel } from "@/platform/keymap";
import { IconButton, Select } from "@/ui";
import { IconButton, Select, lazyComponent } from "@/ui";
import { useProject } from "@/platform/project";
import { activeSchema, schemaSwitchable, sourceLabel, splitTarget, targetOf } from "./model";
import { loadSavedCatalog, offerIntrospection } from "./introspection";
import { analyze, templateContexts, valuesSlot } from "./sql/analyze";
@@ -61,6 +62,9 @@ import { snowflakeLanguage } from "./sql/snowflakeHighlight";
import {
bindConsole,
cancelConsole,
closeInlineResults,
inEditorResults,
setInEditorResults,
consoleSchema,
consoleSource,
executeConsole,
@@ -84,6 +88,7 @@ import {
import styles from "./Database.module.css";
import { tx } from "@/platform/i18n";
import { databaseRequest, projectRequest } from "./requests";
import type { ResultTab } from "./store";
/** `templates` feature's language-data key for finer template contexts. */
const TEMPLATE_CONTEXT_KEY = "openideaTemplateContexts";
@@ -252,6 +257,213 @@ export async function explainInView(view: EditorView, path: string) {
const consolePath = Facet.define<string, string>({ combine: (v) => v[0] ?? "" });
/** An in-editor result and the statement it shows under (mapped through edits). */
interface InlineAnchor {
id: number;
from: number;
to: number;
}
/**
* Where each in-editor result's statement is now and how tall the result is, by result id:
* a console's view can be rebuilt (closed and reopened), and its results go back where they were.
*/
const anchors = new Map<number, { from: number; to: number }>();
const heights = new Map<number, number>();
const MAX_FIT_HEIGHT = 320;
const MIN_HEIGHT = 96;
/** Toolbar, notice, header row, the rows and room for the floating pager, up to `MAX_FIT_HEIGHT`. */
function fitHeight(tab: ResultTab | undefined): number {
const rows = tab?.outcome.result?.rows.length ?? 0;
return Math.max(MIN_HEIGHT, Math.min(MAX_FIT_HEIGHT, 40 + 24 + 24 + Math.max(rows, 1) * 24 + 56));
}
const setInline = StateEffect.define<InlineAnchor[]>();
/** An in-editor result was resized: its widget is redrawn so the editor measures it again. */
const resized = StateEffect.define<null>();
function anchorOf(tab: ResultTab): InlineAnchor {
return { id: tab.id, ...(anchors.get(tab.id) ?? { from: tab.outcome.statement.from, to: tab.outcome.statement.to }) };
}
const inlineField = StateField.define<readonly InlineAnchor[]>({
create: (state) => {
const path = state.facet(consolePath);
return useDatabase
.getState()
.inline.filter((t) => t.path === path)
.map(anchorOf)
.filter((a) => a.to <= state.doc.length);
},
update(value, tr) {
for (const e of tr.effects) {
if (e.is(setInline)) value = e.value;
else if (e.is(resized)) value = [...value];
}
if (!tr.docChanged) return value;
const next: InlineAnchor[] = [];
for (const a of value) {
const from = tr.changes.mapPos(a.from, 1);
const to = tr.changes.mapPos(a.to, -1);
// The statement was deleted: so is its result (the store drops it in `syncInline`).
if (to <= from) continue;
anchors.set(a.id, { from, to });
next.push({ id: a.id, from, to });
}
return next;
},
// Under the statement's last line.
provide: (f) =>
EditorView.decorations.compute([f], (state) =>
Decoration.set(
state
.field(f)
.map((a) =>
Decoration.widget({ widget: new InlineResultWidget(a.id, heightOf(a.id)), block: true, side: 1 }).range(
state.doc.lineAt(a.to).to,
),
),
true,
),
),
});
/**
* Keeps the view's in-editor results in step with the store: a run's new results show under
* their statements (replacing what those statements showed before), closed ones go away.
*/
const syncInline = ViewPlugin.define((view) => {
const path = view.state.facet(consolePath);
let destroyed = false;
const sync = () => {
if (destroyed) return;
const current = view.state.field(inlineField);
const tabs = useDatabase.getState().inline.filter((t) => t.path === path);
const ids = new Set(tabs.map((t) => t.id));
const known = new Set(current.map((a) => a.id));
const len = view.state.doc.length;
const added = tabs
.filter((t) => !known.has(t.id))
.map(anchorOf)
.filter((a) => a.to <= len);
const overlaps = (a: InlineAnchor) => added.some((b) => b.from < a.to && a.from < b.to);
const replaced = current.filter((a) => ids.has(a.id) && overlaps(a)).map((a) => a.id);
const kept = current.filter((a) => ids.has(a.id) && !replaced.includes(a.id));
for (const a of current)
if (!ids.has(a.id)) {
anchors.delete(a.id);
heights.delete(a.id);
}
if (!added.length && kept.length === current.length) return;
for (const a of added) anchors.set(a.id, { from: a.from, to: a.to });
view.dispatch({ effects: setInline.of([...kept, ...added].sort((a, b) => a.to - b.to || a.id - b.id)) });
if (replaced.length) closeInlineResults(replaced);
};
let shown = view.state.field(inlineField);
const stop = useDatabase.subscribe((s, prev) => {
if (s.inline !== prev.inline) queueMicrotask(sync);
});
queueMicrotask(sync);
return {
// Results whose statements were deleted go too.
update(u) {
const next = u.state.field(inlineField);
if (next === shown) return;
const gone = shown.filter((a) => !next.some((b) => b.id === a.id)).map((a) => a.id);
shown = next;
if (gone.length && u.docChanged) queueMicrotask(() => closeInlineResults(gone));
},
destroy: () => {
destroyed = true;
stop();
},
};
});
function heightOf(id: number): number {
return heights.get(id) ?? fitHeight(useDatabase.getState().inline.find((r) => r.id === id));
}
const InlineGrid = lazyComponent(() => import("./ResultsView").then((m) => m.Result));
function InlineResult({ id, view }: { id: number; view: EditorView }) {
const tab = useDatabase((s) => s.inline.find((r) => r.id === id));
const [height, setHeight] = useState(() => heightOf(id));
const drag = useRef<{ y: number; height: number } | null>(null);
const measured = useRef(height);
useEffect(() => {
if (measured.current === height) return;
measured.current = height;
view.dispatch({ effects: resized.of(null) });
}, [height, view]);
if (!tab) return null;
const onPointerDown = (e: PointerEvent<HTMLDivElement>) => {
e.preventDefault();
e.currentTarget.setPointerCapture(e.pointerId);
drag.current = { y: e.clientY, height };
};
const onPointerMove = (e: PointerEvent<HTMLDivElement>) => {
if (!drag.current) return;
const next = Math.max(MIN_HEIGHT, Math.round(drag.current.height + e.clientY - drag.current.y));
heights.set(id, next);
setHeight(next);
};
return (
<div className={styles.inlineResult} style={{ height }}>
<InlineGrid tab={tab} onClose={() => closeInlineResults([id])} />
<div
className={styles.inlineResize}
role="separator"
aria-orientation="horizontal"
aria-label={tx("Resize")}
onPointerDown={onPointerDown}
onPointerMove={onPointerMove}
onPointerUp={() => (drag.current = null)}
/>
</div>
);
}
const inlineRoots = new WeakMap<HTMLElement, ReturnType<typeof createRoot>>();
class InlineResultWidget extends WidgetType {
constructor(
readonly id: number,
readonly height: number,
) {
super();
}
eq(other: InlineResultWidget) {
return other.id === this.id && other.height === this.height;
}
/** A resized result keeps its DOM (and grid state); only the editor's measurement changes. */
updateDOM(dom: HTMLElement) {
return dom.dataset.result === String(this.id);
}
get estimatedHeight() {
return this.height + 12;
}
toDOM(view: EditorView) {
const dom = document.createElement("div");
dom.className = "cm-openidea-db-inline";
dom.contentEditable = "false";
dom.dataset.result = String(this.id);
const root = createRoot(dom);
inlineRoots.set(dom, root);
root.render(<InlineResult id={this.id} view={view} />);
return dom;
}
destroy(dom: HTMLElement) {
const root = inlineRoots.get(dom);
inlineRoots.delete(dom);
queueMicrotask(() => root?.unmount());
}
ignoreEvent() {
return true;
}
}
function ConsoleBar({ path, view }: { path: string; view: EditorView }) {
const sources = useDatabase((s) => s.sources);
const loaded = useDatabase((s) => s.loaded);
@@ -261,6 +473,9 @@ function ConsoleBar({ path, view }: { path: string; view: EditorView }) {
const manual = useDatabase((s) => !!bound && s.manualCommit.has(bound));
const pending = useDatabase((s) => !!bound && s.pendingTx.has(bound));
const databases = useDatabase((s) => s.databases);
const inEditor = useProject((s) => inEditorResults(s.settings));
// SQL resolution scopes in the settings can move the console to another data source.
useProject((s) => s.settings);
const boundId = bound ? splitTarget(bound).id : null;
const supportsTransactions = sourceById(boundId)?.driver !== "clickhouse";
const sqlServer = sourceById(boundId)?.driver === "sqlServer";
@@ -348,6 +563,12 @@ function ConsoleBar({ path, view }: { path: string; view: EditorView }) {
/>
<span className={styles.toolbarSeparator} />
<IconButton icon="history" title="Browse Query History" disabled={!bound} onClick={() => openHistory(path)} />
<IconButton
icon="db-in-editor-results"
title="In-Editor Results"
aria-pressed={inEditor}
onClick={() => void setInEditorResults(!inEditor)}
/>
<span className={styles.toolbarSeparator} />
<Select
aria-label="Row limit"
@@ -779,6 +1000,8 @@ export function consoleExtension(ctx: EditorDocContext): Extension {
consolePath.of(ctx.path),
runField,
runGutter,
inlineField,
syncInline,
showPanel.of(consolePanel(ctx.path)),
EditorState.languageData.of(() => [
{ openideaCompletion: completionSource(ctx.path), [TEMPLATE_CONTEXT_KEY]: templateContextsAt(ctx.path) },
+136
Переглянути файл
@@ -0,0 +1,136 @@
import { act } from "@testing-library/react";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { useProject } from "@/platform/project";
import { consoleExtension } from "./console";
import { SQL_LANGUAGE } from "./sqlLanguage";
import { executeConsole, rerunResult, useDatabase } from "./store";
const backend = vi.hoisted(() => ({ execute: vi.fn(), statements: vi.fn() }));
vi.mock("@/platform/ipc", async (importOriginal) => {
const actual = await importOriginal<typeof import("@/platform/ipc")>();
return {
...actual,
commands: { ...actual.commands, dbExecute: backend.execute, dbStatements: backend.statements },
};
});
vi.mock("@tanstack/react-virtual", () => ({
useVirtualizer: ({ count }: { count: number }) => ({
getTotalSize: () => count * 24,
getVirtualItems: () => Array.from({ length: count }, (_, index) => ({ index, start: index * 24, key: index })),
scrollToIndex: () => {},
}),
}));
const PATH = "/p/console.sql";
const initial = useDatabase.getState();
let runs = 0;
beforeEach(() => {
runs = 0;
useProject.setState({
project: { name: "p", root: "/p", trusted: true } as never,
settings: { database: { inEditorResults: true } } as never,
});
useDatabase.setState({
...initial,
loaded: true,
sources: [{ id: "pg", name: "Local", driver: "postgres", readOnly: false }],
completion: { pg: { defaultSchema: "public", tables: [], foreignKeys: [] } },
consoles: { [PATH]: "pg" },
results: [],
inline: [],
});
backend.statements.mockImplementation((_id: unknown, text: string, from: number, to: number) => {
let at = 0;
const all = text.split(";").flatMap((part) => {
const start = at + part.length - part.trimStart().length;
at += part.length + 1;
const st = part.trim();
return st ? [{ from: start, to: start + st.length, text: st }] : [];
});
const picked = from === to ? all.filter((s) => s.from <= from && from <= s.to + 1) : all;
return Promise.resolve({ status: "ok", data: picked });
});
backend.execute.mockImplementation((_r: unknown, _id: unknown, statements: Array<{ text: string }>) => {
runs++;
return Promise.resolve({
status: "ok",
data: statements.map((st) => ({
statement: st,
result: {
statement: st.text,
columns: [{ name: "v", typeName: "text" }],
rows: [[`${st.text} #${runs}`]],
affected: null,
hasMore: false,
elapsedMs: 1,
executionMs: 1,
},
error: null,
})),
});
});
});
afterEach(() => {
document.body.innerHTML = "";
});
describe("In-Editor Results", () => {
it("keeps a run's result sets out of the result tabs, and re-runs them in place", async () => {
await executeConsole(PATH, "SELECT 1; SELECT 2", 0, 18);
const st = useDatabase.getState();
expect(st.results).toEqual([]);
expect(st.inline.map((r) => r.outcome.statement.text)).toEqual(["SELECT 1", "SELECT 2"]);
const id = st.inline[0]!.id;
await rerunResult(id);
expect(useDatabase.getState().inline[0]!.outcome.result!.rows).toEqual([["SELECT 1 #2"]]);
expect(useDatabase.getState().inline[0]!.id).toBe(id);
});
it("goes to the result tabs while the setting is off", async () => {
useProject.setState({ settings: {} as never });
await executeConsole(PATH, "SELECT 1", 0, 0);
expect(useDatabase.getState().inline).toEqual([]);
expect(useDatabase.getState().results).toHaveLength(1);
});
it("shows each result under its statement, replaces it on a re-run and drops it with the statement", async () => {
const parent = document.createElement("div");
document.body.append(parent);
const doc = "SELECT 1;\nSELECT 2;\n";
const view = new EditorView({
parent,
state: EditorState.create({
doc,
extensions: consoleExtension({ language: SQL_LANGUAGE, path: PATH } as never),
}),
});
const widgets = () => [...view.dom.querySelectorAll(".cm-openidea-db-inline")];
const ids = () => useDatabase.getState().inline.map((r) => r.id);
await act(async () => void (await executeConsole(PATH, view.state.doc.toString(), 0, doc.length)));
await act(async () => {});
expect(widgets()).toHaveLength(2);
const [first, second] = ids();
// Running the first statement again replaces only its own result.
await act(async () => void (await executeConsole(PATH, view.state.doc.toString(), 0, 0)));
await act(async () => {});
expect(ids()).toHaveLength(2);
expect(ids()).toContain(second);
expect(ids()).not.toContain(first);
expect(widgets()).toHaveLength(2);
// Deleting the second statement closes its result.
await act(async () => view.dispatch({ changes: { from: 10, to: 19 } }));
await act(async () => {});
expect(ids()).not.toContain(second);
expect(widgets()).toHaveLength(1);
view.destroy();
});
});
+15
Переглянути файл
@@ -39,6 +39,8 @@ import {
RESULTS_VIEW,
consoleSource,
consoleTints,
inEditorResults,
setInEditorResults,
loadSources,
connect,
loadSchemas,
@@ -79,6 +81,8 @@ function tableTarget(arg: unknown): TableCommandTarget {
return { rows: activeCellGrid()?.selectedRows() ?? [], editor: null };
}
export { activateSettingsPages } from "./settingsPages";
export function activate(): () => void {
const disposers = [
onIdeEvent("dbSourcesChanged", () => {
@@ -135,6 +139,7 @@ export function activate(): () => void {
objects: {},
completion: {},
results: [],
inline: [],
output: [],
activeResult: null,
selectedSource: null,
@@ -262,6 +267,16 @@ export function activate(): () => void {
await (await import("./console")).executeInView(e.view, e.ctx.path);
},
},
{
id: "db.toggleInEditorResults",
title: "In-Editor Results",
description: "Show query results in the editor, under the statements that produced them",
category: "Tools",
icon: "db-in-editor-results",
keywords: ["inline", "results", "console", "grid"],
toggled: () => inEditorResults(),
run: () => setInEditorResults(!inEditorResults()),
},
{
id: "db.executeScript",
title: "Execute SQL Script",
+54
Переглянути файл
@@ -0,0 +1,54 @@
import { beforeEach, describe, expect, it } from "vitest";
import { useProject } from "@/platform/project";
import { resolutionScopeOf, validateResolutionScopes } from "./resolutionScopes";
import { bindConsole, consoleSchema, consoleSource, useDatabase } from "./store";
const scopes = validateResolutionScopes([
{ path: "", dataSource: "main", schema: "" },
{ path: "./src/main/resources/mapper/", dataSource: "orders", schema: "sales" },
{ path: "src/main/resources/mapper/legacy/Old.xml", dataSource: "legacy", schema: "" },
{ path: "src/gone", dataSource: "removed", schema: "" },
]);
describe("SQL resolution scopes", () => {
it("normalises paths and picks the deepest folder or file covering a file, else the project row", () => {
expect(scopes[1]!.path).toBe("src/main/resources/mapper");
const at = (rel: string) => resolutionScopeOf(`/p/${rel}`, "/p", scopes)?.dataSource;
expect(at("src/main/resources/mapper/UserMapper.xml")).toBe("orders");
expect(at("src/main/resources/mapper/legacy/Old.xml")).toBe("legacy");
expect(at("src/main/resources/mapper/legacy/New.xml")).toBe("orders");
// A sibling folder whose name starts the same is not inside.
expect(at("src/main/resources/mapperx/A.xml")).toBe("main");
expect(resolutionScopeOf("/elsewhere/a.sql", "/p", scopes)).toBeNull();
});
it("skips rows whose data source no longer exists", () => {
const known = (id: string) => id !== "removed";
expect(resolutionScopeOf("/p/src/gone/a.sql", "/p", scopes, known)?.dataSource).toBe("main");
});
});
describe("the data source a SQL file resolves against", () => {
beforeEach(() => {
useProject.setState({
project: { name: "p", root: "/p", trusted: true } as never,
settings: { database: { resolutionScopes: scopes } } as never,
});
useDatabase.setState({
sources: ["main", "orders", "legacy"].map((id) => ({ id, name: id, driver: "postgres" as const })),
consoles: {},
consoleSchemas: {},
completion: { orders: { defaultSchema: "public", tables: [], foreignKeys: [] } },
});
});
it("is the one picked in its toolbar, else its scope's (with the scope's schema)", () => {
const file = "/p/src/main/resources/mapper/UserMapper.xml";
expect(consoleSource(file)).toBe("orders");
expect(consoleSchema(file)).toBe("sales");
bindConsole(file, "legacy");
expect(consoleSource(file)).toBe("legacy");
bindConsole(file, null);
expect(consoleSource("/p/scratch.sql")).toBe("main");
});
});
+61
Переглянути файл
@@ -0,0 +1,61 @@
/**
* Languages & Frameworks › SQL Resolution Scopes: the data source (and schema) SQL in a
* file or folder resolves against. The most specific path wins; an empty path is the
* whole project.
*/
export interface SqlResolutionScope {
/** Project-relative file or folder, `/`-separated; empty for the whole project. */
path: string;
dataSource: string;
schema: string;
}
const str = (v: unknown) => (typeof v === "string" ? v : "");
/** Normalises a project-relative path: `/`-separated, without `./` or surrounding slashes. */
export function scopePath(path: string): string {
return path
.trim()
.replace(/\\/g, "/")
.replace(/^(\.\/)+/, "")
.replace(/^\/+|\/+$/g, "");
}
export function validateResolutionScopes(raw: unknown): SqlResolutionScope[] {
if (!Array.isArray(raw)) return [];
return raw.flatMap((r) => {
if (!r || typeof r !== "object") return [];
const o = r as Record<string, unknown>;
return [{ path: scopePath(str(o.path)), dataSource: str(o.dataSource), schema: str(o.schema).trim() }];
});
}
/** The scopes in raw settings (`database.resolutionScopes`). */
export function resolutionScopesOf(settings: unknown): SqlResolutionScope[] {
const database = (settings as { database?: { resolutionScopes?: unknown } } | null)?.database;
return validateResolutionScopes(database?.resolutionScopes);
}
/**
* The scope of `file` (absolute, under project `root`) among `scopes` whose data source
* `known` accepts: the deepest folder or the file itself, else the project's row.
*/
export function resolutionScopeOf(
file: string,
root: string,
scopes: readonly SqlResolutionScope[],
known: (dataSource: string) => boolean = () => true,
): SqlResolutionScope | null {
const base = root.replace(/\\/g, "/").replace(/\/+$/, "");
const normalized = file.replace(/\\/g, "/");
if (!base || !normalized.startsWith(`${base}/`)) return null;
const rel = normalized.slice(base.length + 1);
let best: SqlResolutionScope | null = null;
for (const scope of scopes) {
if (!scope.dataSource || !known(scope.dataSource)) continue;
const p = scope.path;
const covers = !p || rel === p || rel.startsWith(`${p}/`);
if (covers && (!best || p.length > best.path.length)) best = scope;
}
return best;
}
+16
Переглянути файл
@@ -0,0 +1,16 @@
import { lazyComponent } from "@/ui";
import { registerSettingsPage } from "@/workbench/contributions";
/** Settings › Languages & Frameworks › SQL Resolution Scopes (also used by the Settings window). */
export function activateSettingsPages(): () => void {
return registerSettingsPage({
id: "languages.sqlResolutionScopes",
title: "SQL Resolution Scopes",
group: "Languages & Frameworks",
order: 404.5,
projectScope: true,
defaultScope: "project",
keywords: ["sql", "data source", "database", "schema", "mybatis", "mapper", "resolve", "dialect"],
component: lazyComponent(() => import("./SqlScopesPage").then((m) => m.SqlScopesPage)),
});
}
+58 -6
Переглянути файл
@@ -56,6 +56,7 @@ 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";
@@ -87,6 +88,18 @@ export interface ResultTab {
total?: number | null;
/** Kept when the console runs again (Pin Tab); results otherwise replace the console's last ones. */
pinned?: boolean;
/** Shown in the editor under its statement (In-Editor Results), not as a result tab. */
inline?: boolean;
}
/** Database › In-Editor Results: result sets show under their statements instead of in result tabs. */
export function inEditorResults(settings: unknown = useProject.getState().settings): boolean {
return (settings as { database?: { inEditorResults?: unknown } } | null)?.database?.inEditorResults === true;
}
export async function setInEditorResults(on: boolean): Promise<void> {
const settings = await call(commands.settingsSet("global", "database.inEditorResults", JSON.stringify(on)));
useProject.setState({ settings });
}
/** One line of the consoles' Output log (IDEA's Database Console output). */
@@ -167,6 +180,8 @@ interface DatabaseState {
separateProceduresAndFunctions: boolean;
completion: Record<string, DbCompletion>;
results: ResultTab[];
/** Results shown in the editor under their statements (In-Editor Results), oldest first. */
inline: ResultTab[];
/** Result tab id, or `OUTPUT_TAB`. */
activeResult: number | null;
output: OutputLine[];
@@ -234,6 +249,7 @@ export const useDatabase = create<DatabaseState>(() => ({
separateProceduresAndFunctions: readSeparateProceduresAndFunctions(),
completion: {},
results: [],
inline: [],
activeResult: null,
output: [],
running: {},
@@ -869,7 +885,10 @@ export function bindConsole(path: string, id: string | null) {
export function consoleSchema(path: string): string {
const s = useDatabase.getState();
const id = consoleSource(path);
return activeSchema(s.consoleSchemas[path], id ? s.completion[id]?.defaultSchema : undefined);
// A scope's schema applies while the console is on that scope's data source.
const scope = s.consoles[path] ? null : scopeOf(path);
const picked = s.consoleSchemas[path] ?? (scope && scope.dataSource === id ? scope.schema : undefined);
return activeSchema(picked || undefined, id ? s.completion[id]?.defaultSchema : undefined);
}
/** Sets (or clears, for `null`) the console's active schema and remembers it per console file. */
@@ -887,11 +906,26 @@ export function setConsoleSchema(path: string, schema: string | null) {
});
}
/** The data source a console / SQL file runs on: its binding, else the only data source. */
/** The SQL resolution scope of file `path` (Languages & Frameworks › SQL Resolution Scopes), if any. */
function scopeOf(path: string): SqlResolutionScope | null {
const { project, settings } = useProject.getState();
if (!project) return null;
const sources = useDatabase.getState().sources;
return resolutionScopeOf(path, project.root, resolutionScopesOf(settings), (id) =>
sources.some((x) => x.id === splitTarget(id).id),
);
}
/**
* The data source a console / SQL file runs on and resolves against: the one picked in its
* toolbar, else its SQL resolution scope's, else the only data source.
*/
export function consoleSource(path: string): string | null {
const s = useDatabase.getState();
const bound = s.consoles[path];
if (bound && s.sources.some((x) => x.id === splitTarget(bound).id)) return bound;
const scope = scopeOf(path);
if (scope) return scope.dataSource;
return s.sources.length === 1 ? (s.sources[0]!.id ?? null) : null;
}
@@ -1141,6 +1175,10 @@ export async function executeConsole(
const title = index === 1 ? tx`Result ${n}` : tx`Result ${n}-${index}`;
return { id: nextTab++, title, path, sourceId: id, schema, outcome, page: 0, pageSize };
});
if (inEditorResults()) {
useDatabase.setState((s) => ({ inline: [...s.inline, ...tabs.map((t) => ({ ...t, inline: true }))] }));
return outcomes;
}
const failed = outcomes.some((o) => o.error);
useDatabase.setState((s) => ({
results: replaceResults(s.results, path, tabs),
@@ -1282,7 +1320,7 @@ export async function openObjectDdl(id: string, schema: string, kind: DbObjectKi
/** Re-runs the statement of result tab `tabId`, replacing its rows (a plan tab explains it again). */
export async function rerunResult(tabId: number): Promise<void> {
const tab = useDatabase.getState().results.find((r) => r.id === tabId);
const tab = findResult(tabId);
if (!tab || tab.busy) return;
if (tab.plan) {
patchResult(tabId, { busy: true });
@@ -1305,8 +1343,16 @@ export function pageable(tab: ResultTab): boolean {
return !tab.plan && isReadOnlyQuery(tab.outcome.statement.text, sourceById(tab.sourceId)?.driver ?? "sqlite");
}
/** Result tab `tabId`, in the Services view or in an editor. */
export function findResult(tabId: number): ResultTab | undefined {
const st = useDatabase.getState();
return st.results.find((r) => r.id === tabId) ?? st.inline.find((r) => r.id === tabId);
}
function patchResult(tabId: number, p: Partial<ResultTab>) {
useDatabase.setState((s) => ({ results: s.results.map((r) => (r.id === tabId ? { ...r, ...p } : r)) }));
const patch = (list: ResultTab[]) =>
list.some((r) => r.id === tabId) ? list.map((r) => (r.id === tabId ? { ...r, ...p } : r)) : list;
useDatabase.setState((s) => ({ results: patch(s.results), inline: patch(s.inline) }));
}
/**
@@ -1315,7 +1361,7 @@ function patchResult(tabId: number, p: Partial<ResultTab>) {
* `rerun` also forgets the counted total.
*/
export async function loadResultPage(tabId: number, page: number, pageSize: number, rerun = false): Promise<void> {
const tab = useDatabase.getState().results.find((r) => r.id === tabId);
const tab = findResult(tabId);
if (!tab || tab.busy || tab.plan) return;
if (page > 0 && !pageable(tab)) return;
patchResult(tabId, { busy: true });
@@ -1363,7 +1409,7 @@ export function countable(tab: ResultTab): boolean {
/** Counts the rows of result tab `tabId`'s whole query (the pager's "of 501+"). */
export async function countResult(tabId: number): Promise<number | null> {
const tab = useDatabase.getState().results.find((r) => r.id === tabId);
const tab = findResult(tabId);
if (!tab || tab.busy || !countable(tab)) return null;
const text = countQuery(tab.outcome.statement.text)!;
patchResult(tabId, { busy: true });
@@ -1468,6 +1514,12 @@ export function closeResult(id: number) {
});
}
/** Closes in-editor results `ids`. */
export function closeInlineResults(ids: readonly number[]) {
if (!ids.length) return;
useDatabase.setState((s) => ({ inline: s.inline.filter((r) => !ids.includes(r.id)) }));
}
export function pinResult(id: number, pinned: boolean) {
patchResult(id, { pinned });
}
+9
Переглянути файл
@@ -20,6 +20,7 @@ const proc = (p: Partial<AttachableProcess> & Pick<AttachableProcess, "pid" | "k
name: p.kind,
commandLine: `${p.kind} app`,
adapter: {
unity: "unity",
java: "java-debug",
node: "js-debug",
python: "debugpy",
@@ -49,6 +50,14 @@ const list = [
];
describe("Attach to Process popup model", () => {
it("attaches the chosen Unity Editor by its exact ID without launching or using a native adapter", async () => {
const launch = await attachConfig(proc({ pid: 1234, kind: "unity", name: "Unity Editor" }), "/game");
expect(launch).toMatchObject({ adapter: "unity", request: "attach", program: null, cwd: "/game" });
expect(JSON.parse(launch.extraJson!)).toEqual({
name: "Unity Editor (1234)",
__exceptionOptions: [],
});
});
it("groups processes by debugger in IDEA's order with counts", () => {
const rows = attachRows(list, "");
expect(rows.filter((r) => r.kind === "group").map((r) => r.kind === "group" && `${r.label}:${r.count}`)).toEqual([
+1
Переглянути файл
@@ -12,6 +12,7 @@ describe("missing debug adapters", () => {
});
it("offers the managed install of a missing adapter binary", () => {
expect(missingAdapter("unity", unavailable("debug adapter `unity` not found"))?.tool).toBe("unity-debug");
const e = unavailable(
"debug adapter `js-debug` not found (`js-debug-adapter` is neither installed by OpenIDEA nor on PATH)",
);
+142
Переглянути файл
@@ -0,0 +1,142 @@
import { afterEach, beforeEach, expect, it, vi } from "vitest";
import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
import type { AttachableProcess, ProjectInfo, RunConfig } from "@/platform/ipc";
const mocks = vi.hoisted(() => ({ discover: vi.fn(), generic: vi.fn(), start: vi.fn(), install: vi.fn() }));
vi.mock("@/platform/ipc", async (original) => {
const real = await original<typeof import("@/platform/ipc")>();
return {
...real,
isTauri: () => true,
commands: {
...real.commands,
debugUnityProcesses: mocks.discover,
debugAttachableProcesses: mocks.generic,
},
};
});
vi.mock("../state", async (original) => ({
...(await original<typeof import("../state")>()),
startSession: mocks.start,
}));
import { registerAction } from "@/platform/actions";
import { useProject } from "@/platform/project";
import { openAttachPopup, installAttachAdapter } from "../attachPopup";
import { DebuggerOverlays } from "../ui/Overlays";
import { useOverlays } from "../ui/popoverStore";
const editor: AttachableProcess = {
pid: 42,
name: "Unity Editor",
commandLine: "/game",
adapter: "unity",
kind: "unity",
host: null,
port: null,
};
const ok = (data: AttachableProcess[]) => ({ status: "ok" as const, data });
function deferred() {
let resolve!: (result: ReturnType<typeof ok>) => void;
const promise = new Promise<ReturnType<typeof ok>>((r) => {
resolve = r;
});
return { promise, resolve };
}
let dispose: () => void;
beforeEach(() => {
vi.clearAllMocks();
useProject.setState({ project: { root: "/game" } as ProjectInfo });
useOverlays.setState({ attach: null });
mocks.discover.mockResolvedValue(ok([editor]));
mocks.start.mockResolvedValue(1);
mocks.install.mockResolvedValue(undefined);
dispose = registerAction({ id: "tools.install", title: "Install", run: mocks.install });
});
afterEach(() => {
cleanup();
dispose();
useOverlays.setState({ attach: null });
useProject.setState({ project: null });
});
it("selects the requested Unity process and starts a non-rerunnable attach session", async () => {
const otherEditor = { ...editor, pid: 84, commandLine: "/other-game" };
mocks.discover.mockResolvedValueOnce(ok([otherEditor, editor]));
await openAttachPopup("unity");
render(<DebuggerOverlays />);
expect(screen.getByRole("dialog", { name: "Attach to Unity Process" })).toBeTruthy();
expect(screen.getByText(/switch to Debug Mode/)).toBeTruthy();
fireEvent.keyDown(screen.getByRole("textbox", { name: "Filter processes" }), { key: "ArrowDown" });
fireEvent.click(screen.getByRole("button", { name: "Attach" }));
await waitFor(() =>
expect(mocks.start).toHaveBeenCalledWith(
expect.objectContaining({
request: "attach",
adapter: "unity",
cwd: "/game",
extraJson: expect.stringContaining("Unity Editor (42)"),
}),
{ rerunnable: false },
),
);
expect(mocks.generic).not.toHaveBeenCalled();
expect(useOverlays.getState().attach).toBeNull();
});
it("associates the selected run configuration after refreshing the picker", async () => {
const runConfig = { id: "unity-editor", name: "Unity Editor", kind: "unity-editor" } as RunConfig;
await openAttachPopup("unity", runConfig);
render(<DebuggerOverlays />);
fireEvent.click(screen.getByRole("button", { name: "Refresh" }));
await waitFor(() => expect(useOverlays.getState().attach?.processes).toEqual([editor]));
fireEvent.click(screen.getByRole("button", { name: "Attach" }));
await waitFor(() => expect(mocks.start).toHaveBeenCalledWith(expect.anything(), { rerunnable: false, runConfig }));
});
it("offers installation for a missing adapter and retries discovery afterwards", async () => {
mocks.discover.mockResolvedValueOnce({
status: "error",
error: { kind: "unavailable", message: "debug adapter `unity` not found" },
});
await openAttachPopup("unity");
render(<DebuggerOverlays />);
fireEvent.click(screen.getByRole("button", { name: "Install Unity Debugger" }));
await waitFor(() => expect(useOverlays.getState().attach?.processes).toEqual([editor]));
expect(mocks.install).toHaveBeenCalledWith(expect.objectContaining({ arg: "unity-debug" }));
});
it("does not replace a refreshed picker with an older discovery response", async () => {
const old = deferred();
mocks.discover.mockReturnValueOnce(old.promise);
const first = openAttachPopup("unity");
await openAttachPopup("unity");
old.resolve(ok([]));
await first;
expect(useOverlays.getState().attach?.processes).toEqual([editor]);
});
it("does not reopen a cancelled picker when discovery finishes", async () => {
const pending = deferred();
mocks.discover.mockReturnValueOnce(pending.promise);
const request = openAttachPopup("unity");
useOverlays.setState({ attach: null });
pending.resolve(ok([editor]));
await request;
expect(useOverlays.getState().attach).toBeNull();
});
it("does not attach to an old project's process or retry installation after switching projects", async () => {
await openAttachPopup("unity");
render(<DebuggerOverlays />);
act(() => useProject.setState({ project: { root: "/other" } as ProjectInfo }));
fireEvent.click(screen.getByRole("button", { name: "Attach" }));
expect(mocks.start).not.toHaveBeenCalled();
act(() =>
useOverlays.setState({
attach: { processes: [], error: "missing", mode: "unity", projectRoot: "/game", installTool: "unity-debug" },
}),
);
await installAttachAdapter();
expect(mocks.discover).toHaveBeenCalledTimes(1);
});
+12 -23
Переглянути файл
@@ -80,14 +80,10 @@ import { expressionAt, valueHint } from "./editor/valueTooltip";
import { mouseEvaluateTarget } from "./editor/quickEvaluate";
import { showHint } from "@/editor/lsp/hint";
import { pausedLineTargets, startInlineSmartStep } from "./editor/smartStep";
import {
openBreakpointsDialog,
openConfigChooser,
openEvaluateDialog,
openSmartStepChooser,
useOverlays,
} from "./ui/popoverStore";
import { openBreakpointsDialog, openConfigChooser, openEvaluateDialog, openSmartStepChooser } from "./ui/popoverStore";
import { tx } from "@/platform/i18n";
import { openAttachPopup } from "./attachPopup";
export { openAttachPopup } from "./attachPopup";
function isRunConfig(arg: unknown): arg is RunConfig {
return !!arg && typeof arg === "object" && "command" in arg && "args" in arg && "debugAdapter" in arg;
@@ -180,22 +176,6 @@ async function smartStepInto() {
if (!startInlineSmartStep(t.s.id, t.thread, targets)) openSmartStepChooser(t.s.id, t.thread, targets);
}
/** Opens the Attach to Process popup and loads the process list. */
export async function openAttachPopup() {
if (!isTauri()) {
notifications().notify({ group: "run", level: "warning", title: "Attaching needs the desktop app" });
return;
}
useOverlays.setState({ attach: { processes: null, error: null } });
try {
const processes = await call(commands.debugAttachableProcesses());
if (useOverlays.getState().attach) useOverlays.setState({ attach: { processes, error: null } });
} catch (e) {
if (useOverlays.getState().attach)
useOverlays.setState({ attach: { processes: [], error: errorText(e) || "Cannot list processes" } });
}
}
function cursor(): { path: string; line: number; selection: string } | null {
const ed = activeEditor();
if (!ed) return null;
@@ -891,6 +871,15 @@ export function registerDebugActions(): () => void {
description: "Attach the debugger to a running Java, Node.js, Python, Go or native process",
run: () => void openAttachPopup(),
},
{
id: "debug.attachUnity",
title: "Attach to Unity Process",
category: "Run",
icon: "debug",
hidden: true,
when: "projectOpen",
run: ({ arg }) => openAttachPopup("unity", arg as RunConfig | undefined),
},
{
id: "debug.debugInBrowser",
title: "Debug in Browser",
+10 -1
Переглянути файл
@@ -7,6 +7,7 @@ import type { AttachKind, AttachableProcess, LaunchConfig } from "@/platform/ipc
import { javaAttachConfig } from "./java";
export const KIND_LABELS: Record<AttachKind, string> = {
unity: "Unity Editor",
java: "Java (JDWP)",
node: "Node.js",
python: "Python (debugpy)",
@@ -15,7 +16,7 @@ export const KIND_LABELS: Record<AttachKind, string> = {
native: "Native (LLDB)",
};
const KIND_ORDER: AttachKind[] = ["java", "node", "python", "dotnet", "go", "native"];
const KIND_ORDER: AttachKind[] = ["unity", "java", "node", "python", "dotnet", "go", "native"];
export type AttachRow =
| { kind: "group"; key: string; label: string; count: number }
@@ -64,6 +65,14 @@ function base(p: AttachableProcess, cwd: string, extra: Record<string, unknown>)
export async function attachConfig(p: AttachableProcess, root: string): Promise<LaunchConfig> {
const skip = workflowSettings().debugger.skipLibraryCode;
switch (p.kind) {
case "unity":
return {
...base(p, root, {
name: `Unity Editor (${p.pid})`,
__exceptionOptions: [],
}),
adapter: "unity",
};
case "java":
return javaAttachConfig(
{ name: `${p.name} (${p.pid})`, module: "", hostName: p.host ?? "localhost", port: p.port! },
+44
Переглянути файл
@@ -0,0 +1,44 @@
import { executeAction } from "@/platform/actions";
import { call, commands, isTauri, type RunConfig } from "@/platform/ipc";
import { useProject } from "@/platform/project";
import { notifications } from "@/workbench/contributions";
import { missingAdapter } from "./missingAdapter";
import { useOverlays } from "./ui/popoverStore";
/** Applies only the latest request of the open popup; results for a closed or refreshed one are dropped. */
export async function openAttachPopup(mode: "all" | "unity" = "all", runConfig?: RunConfig) {
if (!isTauri()) {
notifications().notify({ group: "run", level: "warning", title: "Attaching needs the desktop app" });
return;
}
const projectRoot = useProject.getState().project?.root ?? null;
const pending = { processes: null, error: null, mode, projectRoot, runConfig };
useOverlays.setState({ attach: pending });
const current = () =>
useOverlays.getState().attach === pending && (useProject.getState().project?.root ?? null) === projectRoot;
try {
const processes = await call(
mode === "unity" ? commands.debugUnityProcesses() : commands.debugAttachableProcesses(),
);
if (current()) useOverlays.setState({ attach: { ...pending, processes } });
} catch (e) {
if (current())
useOverlays.setState({
attach: {
...pending,
processes: [],
error: e instanceof Error ? e.message : String(e),
installTool: mode === "unity" ? missingAdapter("unity", e)?.tool : undefined,
},
});
}
}
export async function installAttachAdapter() {
const state = useOverlays.getState().attach;
if (!state?.installTool) return;
await executeAction("tools.install", state.installTool);
if (useOverlays.getState().attach === state && useProject.getState().project?.root === state.projectRoot) {
await openAttachPopup(state.mode, state.runConfig);
}
}
+1
Переглянути файл
@@ -145,6 +145,7 @@ export function activate(): () => void {
useProject.subscribe((s, prev) => {
const root = s.project?.root ?? null;
if (root !== (prev.project?.root ?? null) || s.project?.trusted !== prev.project?.trusted) {
useOverlays.setState({ attach: null });
resetSessions();
loadWatches(root);
loadBreakpoints(root);
+1
Переглянути файл
@@ -8,6 +8,7 @@ import { tx } from "@/platform/i18n";
/** Adapters the tools installer can provide (adapter id → tool name). */
const INSTALLABLE: Record<string, { tool: string; title: string }> = {
unity: { tool: "unity-debug", title: "Unity Debugger is not installed" },
"kotlin-debug-adapter": { tool: "kotlin-debug-adapter", title: "The Kotlin debugger is not installed" },
netcoredbg: { tool: "netcoredbg", title: "netcoredbg is not installed" },
debugpy: { tool: "debugpy", title: "debugpy is not installed" },
+60 -4
Переглянути файл
@@ -33,6 +33,7 @@ import {
type SpecialBreakpoint,
} from "../breakpoints/special";
import { attachConfig, attachDetail, attachRows, type AttachRow } from "../attach";
import { openAttachPopup, installAttachAdapter } from "../attachPopup";
import {
exceptionGroups,
filterHint,
@@ -915,6 +916,7 @@ function AttachPopup() {
const root = useProject((s) => s.project?.root ?? null);
const [filter, setFilter] = useState("");
const [active, setActive] = useState(0);
const [installing, setInstalling] = useState(false);
const rows = useMemo(() => attachRows(state?.processes ?? [], filter), [state?.processes, filter]);
const firstItem = rows.findIndex((r) => r.kind === "process");
const activeIndex = rows[active]?.kind === "process" ? active : firstItem;
@@ -925,10 +927,11 @@ function AttachPopup() {
useOverlays.setState({ attach: null });
};
const attach = async (p: AttachableProcess) => {
if (state.projectRoot !== undefined && state.projectRoot !== root) return close();
close();
if (!root) return;
try {
await startSession(await attachConfig(p, root), { rerunnable: false });
await startSession(await attachConfig(p, root), { rerunnable: false, runConfig: state.runConfig });
} catch (e) {
notifications().notify({
group: "run",
@@ -948,8 +951,44 @@ function AttachPopup() {
}
};
return (
<Dialog open onClose={close} title="Attach to Process" width={640} position="top" aria-label="Attach to process">
<Dialog
open
onClose={close}
title={state.mode === "unity" ? "Attach to Unity Process" : "Attach to Process"}
width={640}
position="top"
aria-label={state.mode === "unity" ? "Attach to Unity Process" : "Attach to process"}
buttons={[
{
label: "Refresh",
role: "extra",
disabled: state.processes === null || installing,
onClick: () => {
setActive(0);
void openAttachPopup(state.mode, state.runConfig);
},
},
{ label: "Cancel", role: "cancel", onClick: close },
{
label: "Attach",
role: "default",
disabled: rows[activeIndex]?.kind !== "process" || installing,
onClick: () => {
const row = rows[activeIndex];
if (row?.kind === "process") void attach(row.process);
},
},
]}
>
<div className={styles.evalBody}>
{state.mode === "unity" && (
<p>
<T>
Open the project in Unity Editor, enable Editor Attaching and switch to Debug Mode. Select its process
below. Stopping debugging disconnects without closing Unity.
</T>
</p>
)}
<Input
value={filter}
onChange={(e) => {
@@ -975,7 +1014,20 @@ function AttachPopup() {
<T>Loading processes…</T>
</div>
) : state.error ? (
<div className={styles.empty}>{state.error}</div>
<div className={styles.empty}>
<div>{state.error}</div>
{state.installTool && (
<Button
disabled={installing}
onClick={() => {
setInstalling(true);
void installAttachAdapter().finally(() => setInstalling(false));
}}
>
{installing ? "Installing…" : "Install Unity Debugger"}
</Button>
)}
</div>
) : (
<List<AttachRow>
items={rows}
@@ -996,7 +1048,11 @@ function AttachPopup() {
className={styles.attachList}
empty={
<div className={styles.empty}>
{filter ? tx`No attachable processes match the filter.` : tx`No attachable processes.`}
{filter
? tx`No attachable processes match the filter.`
: state.mode === "unity"
? tx`No Unity Editor processes found. Open Unity Editor, then refresh.`
: tx`No attachable processes.`}
</div>
}
renderItem={(r) =>
+8 -1
Переглянути файл
@@ -15,7 +15,14 @@ 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 } | null;
attach: {
processes: AttachableProcess[] | null;
error: string | null;
mode?: "all" | "unity";
projectRoot?: string | null;
installTool?: string;
runConfig?: RunConfig;
} | 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.
+2 -1
Переглянути файл
@@ -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 } from "./database";
import { activate as database, activateSettingsPages as databasePages } 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,6 +188,7 @@ export function activateSettingsWindowFeatures(parent: string): () => void {
["vim", vimPages],
["vcs", vcsPages],
["github", githubPages],
["database", databasePages],
];
return activateAll("settings pages", pages);
}
+46 -2
Переглянути файл
@@ -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, registerAction } from "@/platform/actions";
import { executeAction, executeActionFrom, getAction, isActionEnabled, registerAction } from "@/platform/actions";
import { setContext } from "@/platform/context";
import type { RunConfig } from "@/platform/ipc";
import type { ProjectInfo, RunConfig } from "@/platform/ipc";
import {
registerMenuGroup,
registerRunConfigType,
@@ -10,6 +10,7 @@ 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";
@@ -52,6 +53,7 @@ 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: [] });
@@ -61,9 +63,51 @@ 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,6 +67,32 @@ 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,6 +104,7 @@ 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 = "";
@@ -171,6 +172,7 @@ 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);
@@ -488,6 +490,14 @@ 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",
+20 -1
Переглянути файл
@@ -65,6 +65,7 @@ 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";
@@ -240,11 +241,29 @@ 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
: (defaultSelection(saved)?.id ?? CURRENT_FILE);
: (configs.find((config) => config.kind === UNITY_CONFIG_KIND)?.id ??
defaultSelection(saved)?.id ??
CURRENT_FILE);
useRun.setState({
configs,
temporary: temps.map((t) => t.id),
+9
Переглянути файл
@@ -28,6 +28,7 @@ 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";
@@ -475,6 +476,14 @@ 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
Переглянути файл
@@ -0,0 +1,13 @@
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,8 +156,10 @@ 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);
});
});
+3 -2
Переглянути файл
@@ -152,10 +152,11 @@ function PageHost({
const spec = page ? builtinSpec(page.id) : undefined;
const projectScope = !!(spec?.projectScope ?? page?.projectScope) && hasProject && !newProjects;
const scopeKey = spec?.scopeGroup ?? pageId;
const chosen = useSettingsDialog((s) => s.scopes[scopeKey]) ?? spec?.defaultScope;
const defaultScope = spec?.defaultScope ?? page?.defaultScope;
const chosen = useSettingsDialog((s) => s.scopes[scopeKey]) ?? 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" && spec?.defaultScope === "project");
const globalNote = newProjects || (projectScope && scope === "global" && defaultScope === "project");
const ctx = useMemo(() => ({ pageId, scope }), [pageId, scope]);
const form = useSettingsFormFor(pageId, scope);
const focus = useSettingsDialog((s) => s.focus);
+9 -1
Переглянути файл
@@ -108,6 +108,8 @@ 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>;
}
@@ -160,7 +162,12 @@ 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, groups: {} };
export const DEFAULT_NOTIFICATIONS: NotificationsValid = {
balloons: true,
sound: false,
systemNotifications: true,
groups: {},
};
type Obj = Record<string, unknown>;
const obj = (v: unknown): Obj => (v && typeof v === "object" && !Array.isArray(v) ? (v as Obj) : {});
@@ -263,6 +270,7 @@ 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,6 +63,8 @@ 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;
@@ -165,6 +167,7 @@ export const DEFAULT_SETTINGS: ValidSettings = {
plugins: {},
scopes: [],
fileColors: DEFAULT_FILE_COLORS,
database: { inEditorResults: false, resolutionScopes: [] },
general: {
reopenLastProject: true,
confirmExit: true,
@@ -340,6 +343,17 @@ 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),
+6 -1
Переглянути файл
@@ -1086,12 +1086,17 @@ export const BEHAVIOR_PAGES: PageSpec[] = [
title: "Notifications",
group: APPEARANCE_GROUP,
order: 2,
keywords: ["balloon", "popup", "sound", "alerts"],
keywords: ["balloon", "popup", "sound", "alerts", "system", "os"],
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",
},
],
},
{
+19 -1
Переглянути файл
@@ -1,4 +1,13 @@
{
"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",
@@ -1959,5 +1968,14 @@
"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…"
"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."
}
+18 -1
Переглянути файл
@@ -1,4 +1,12 @@
{
"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",
@@ -8352,5 +8360,14 @@
"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…": "编辑文件颜色…"
"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.": "路径相对于项目根目录。对某个文件生效的是包含它的最深一级文件夹或该文件本身。"
}
+1
Переглянути файл
@@ -383,6 +383,7 @@ 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
Переглянути файл
@@ -0,0 +1,4 @@
<!-- 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,6 +758,8 @@ 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;
@@ -1089,6 +1091,8 @@ 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";
}
/**
+11 -2
Переглянути файл
@@ -1,7 +1,7 @@
/** Notification center: balloons + history, backing `NotificationService`. */
import type { ReactNode } from "react";
import { create } from "zustand";
import { call, commands, onIdeEvent } from "@/platform/ipc";
import { call, commands, isTauri, onIdeEvent } from "@/platform/ipc";
import { buildToolRecovery } from "@/platform/buildToolRecovery";
import { txTemplate } from "@/platform/i18n";
import { useProject } from "@/platform/project";
@@ -154,7 +154,16 @@ 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) };
});
if (balloon && prefs.sound) playSound();
// 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(() => {});
}
return id;
}