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

..
Автор 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
105 змінених файлів з 336 додано та 4349 видалено

No files matched your search

+5 -20
Переглянути файл
@@ -134,10 +134,7 @@ fn codex_meta(line: &serde_json::Value) -> Option<(String, Option<String>)> {
let payload =
line.get("payload").filter(|p| p.get("type").and_then(serde_json::Value::as_str) == Some("session_meta"));
let inner = payload.and_then(|p| p.get("payload")).or_else(|| {
line.get("type")
.and_then(serde_json::Value::as_str)
.filter(|t| *t == "session_meta")
.map(|_| line.get("payload").unwrap_or(line))
line.get("type").and_then(serde_json::Value::as_str).filter(|t| *t == "session_meta").and(Some(line))
})?;
let id = inner.get("id").and_then(serde_json::Value::as_str)?.to_owned();
let cwd = inner.get("cwd").and_then(serde_json::Value::as_str).map(str::to_owned);
@@ -296,28 +293,16 @@ mod tests {
assert_eq!(sessions[0].title, "hello there");
}
#[test]
fn codex_meta_accepts_current_and_legacy_shapes() {
let meta = json!({"id": "thread-1", "cwd": "/work/app"});
for line in [
json!({"type": "session_meta", "payload": meta}),
json!({"payload": {"type": "session_meta", "payload": meta}}),
json!({"type": "session_meta", "id": "thread-1", "cwd": "/work/app"}),
] {
assert_eq!(codex_meta(&line), Some(("thread-1".to_owned(), Some("/work/app".to_owned()))));
}
}
#[test]
fn lists_codex_rollouts_with_meta() {
let tmp = tempfile::tempdir().unwrap();
write(
&tmp.path().join("sessions/2026/01/02/rollout-01.jsonl"),
&[
json!({"timestamp": "t", "type": "session_meta",
"payload": {"id": "thread-1", "cwd": "/work/app"}}),
json!({"timestamp": "t", "type": "event_msg",
"payload": {"type": "user_message", "message": "add tests"}}),
json!({"timestamp": "t", "payload": {"type": "session_meta",
"payload": {"id": "thread-1", "cwd": "/work/app"}}}),
json!({"timestamp": "t", "payload": {"type": "user_message",
"payload": {"message": "add tests"}}}),
],
);
write(&tmp.path().join("sessions/notes.jsonl"), &[json!({"nope": true})]);
-3
Переглянути файл
@@ -1347,9 +1347,6 @@ pub struct JavaSettings {
pub jdtls_vm_args: String,
/// Share one JDT LS across builds in an ordinary project window; other windows remain separate.
pub jdtls_shared: bool,
/// JDK homes added by hand (Platform Settings › SDKs › Add JDK from Disk…), listed with the
/// detected ones.
pub added_jdks: Vec<String>,
/// Build Tools › Maven.
pub maven: MavenSettings,
/// Build Tools › Gradle.
+3 -10
Переглянути файл
@@ -1244,18 +1244,11 @@ impl DebugManager {
// rdbg's terminate exits the Ruby process without terminating its children.
let graceful =
terminate && s.request == "launch" && s.adapter != "rdbg" && s.supports("supportsTerminateRequest");
// A program suspended in the debugger cannot act on SIGTERM, and on macOS not even die of
// SIGKILL while the debugger holds it: it is killed (with what it started) and the adapter
// is told to end it. A killed program has no shutdown output to wait for.
let killed = own_terminate && !graceful && s.suspended.get();
if killed {
crate::session::signal_debuggee(s, true).await;
}
if !s.conn.is_closed() {
if graceful {
let _ = s.conn.request_timeout("terminate", json!({ "restart": false }), SHUTDOWN_TIMEOUT).await;
}
if !graceful && (!own_terminate || killed) {
if !graceful && !own_terminate {
let _ = s
.conn
.request_timeout(
@@ -1266,7 +1259,7 @@ impl DebugManager {
.await;
}
}
if own_terminate && !graceful && !killed {
if own_terminate && !graceful {
// Signal before anything else: waiting on a request the adapter may not answer
// would delay the shutdown the console is supposed to show.
crate::session::signal_debuggee(s, false).await;
@@ -1285,7 +1278,7 @@ impl DebugManager {
// lets Run start again into an occupied port, so wait for the program first — with the
// connection still open, so a second Stop can find the session and kill it.
crate::session::wait_for_debuggee(s, terminate).await;
if terminate && s.request == "launch" && !killed {
if terminate && s.request == "launch" {
// The adapter reports `terminated` only after it has drained the program's console
// (java-debug waits up to 5 s for the pump): closing before that drops the last
// shutdown lines from the console.
-46
Переглянути файл
@@ -527,14 +527,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
}
}
"disconnect" => {
// Like Delve: the adapter ends the program it launched.
#[cfg(unix)]
if msg["arguments"]["terminateDebuggee"] == true
&& let Some(pid) = script.debuggee_pid
{
// SAFETY: plain syscall on the test's own child process.
unsafe { libc::kill(pid as i32, libc::SIGKILL) };
}
ok!(msg, Value::Null);
let _ = w.lock().await.shutdown().await;
break;
@@ -2327,44 +2319,6 @@ async fn stop_waits_for_the_launched_program_to_exit() {
h.wait_event(|e| matches!(e, DebugEvent::Terminated)).await;
}
/// Delve and other adapters without `terminate`: a program stopped at a breakpoint cannot
/// handle the SIGTERM Stop sends, so Stop has the adapter end it instead of waiting out the grace period.
#[cfg(unix)]
#[tokio::test]
async fn stop_kills_a_program_suspended_at_a_breakpoint_at_once() {
let mut child = std::process::Command::new("python3")
.args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(30)"])
.spawn()
.unwrap();
let pid = child.id();
let exited = Arc::new(AtomicBool::new(false));
{
let exited = exited.clone();
std::thread::spawn(move || {
let _ = child.wait();
exited.store(true, Ordering::Release);
});
}
let h = harness(Script { debuggee_pid: Some(pid), supports_terminate: false, ..Default::default() });
let id = h.start(config()).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
let session = h.manager.session(id).unwrap();
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
tokio::time::sleep(Duration::from_millis(200)).await; // let the program install its trap
let started = Instant::now();
h.manager.stop(id).await.unwrap();
let elapsed = started.elapsed();
assert!(elapsed < Duration::from_secs(3), "stop waited {elapsed:?} for a suspended program");
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], true);
let deadline = Instant::now() + Duration::from_secs(2);
while !exited.load(Ordering::Acquire) {
assert!(Instant::now() < deadline, "the suspended program was left running");
tokio::time::sleep(Duration::from_millis(10)).await;
}
}
#[cfg(unix)]
#[tokio::test]
async fn a_second_stop_kills_the_program_instead_of_waiting() {
-9
Переглянути файл
@@ -190,7 +190,6 @@ impl Host {
open_locks: Default::default(),
};
host.apply_proxy();
host.apply_added_jdks();
ops::agent::move_user_mcp_values(&host);
host
}
@@ -565,11 +564,3 @@ mod tests {
host.close_project("main");
}
}
impl Host {
/// Lists the JDKs added by hand (global Settings › SDKs) with the detected ones.
pub fn apply_added_jdks(&self) {
let homes = self.global_settings.effective().languages.java.added_jdks;
ide_sdk::java::set_added_jdks(homes.into_iter().map(PathBuf::from));
}
}
-3
Переглянути файл
@@ -232,9 +232,6 @@ pub fn set_settings(
if key == "ssh" || key.starts_with("ssh.") {
host.ssh.set_configs(host.global_settings.effective().ssh.configs);
}
if key == "languages" || key == "languages.java" || key.starts_with("languages.java.addedJdks") {
host.apply_added_jdks();
}
if is_proxy {
host.apply_proxy();
}
-14
Переглянути файл
@@ -37,9 +37,6 @@ pub struct ProjectInterpreter {
pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<Vec<Sdk>> {
host.require_trust(window)?;
let project = host.project(window).ok();
if kind == SdkKind::Jdk {
host.apply_added_jdks();
}
let root = project.as_ref().map(|p| p.root.clone());
// The interpreter the project uses is a choice even where detection doesn't look (a
// virtualenv in a subfolder, one picked by path), so it shows by name and version.
@@ -375,20 +372,9 @@ pub async fn sdk_python_pip(
result?
}
/// The JDK whose home is `path` (a macOS bundle too), as the SDK list shows it; `None` when
/// `path` is no JDK home (Add JDK from Disk…).
pub async fn sdk_jdk_at(path: String) -> IdeResult<Option<Sdk>> {
tokio::task::spawn_blocking(move || {
ide_sdk::java::jdk_at(std::path::Path::new(&path)).map(|j| ide_sdk::jdk_sdk(&j))
})
.await
.map_err(join_err)
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("sdk_detect", |c| async move { sdk_detect(&c.host, &c.window, c.arg("kind")?).await });
d.add("sdk_jdk_at", |c| async move { sdk_jdk_at(c.arg("path")?).await });
d.add(
"sdk_python_project_interpreters",
|c| async move { sdk_python_project_interpreters(&c.host, &c.window).await },
+3 -8
Переглянути файл
@@ -677,14 +677,9 @@ impl Shared {
}
let previous =
self.setting_snapshots.lock().insert((client.map(str::to_owned), pkg.id().into()), current.clone());
match previous {
// First contact since the plugin loaded (fresh install, update,
// re-enable): hand over every current key, so the synthetic
// post-install `settings-changed` wakes the plugin instead of being
// dropped for having no diff yet.
None => current.into_keys().collect(),
Some(old) => current.into_iter().filter(|(k, v)| old.get(k) != Some(v)).map(|(k, _)| k).collect(),
}
previous
.map(|old| current.into_iter().filter(|(k, v)| old.get(k) != Some(v)).map(|(k, _)| k).collect())
.unwrap_or_default()
}
pub fn status_snapshot(&self, client: &str) -> Vec<super::PluginStatusItem> {
+2 -39
Переглянути файл
@@ -144,7 +144,7 @@ impl Host {
let lsp = LspManager::new(root.clone(), languages.clone(), sink.clone());
crate::plugins::injections::configure_lsp(&lsp);
lsp.set_execution_allowed(trusted.load(Ordering::Acquire));
lsp.set_content_roots(language_server_roots(&root, extra_roots.clone()));
lsp.set_content_roots(extra_roots.clone());
lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
&root,
&settings.effective().languages.java.maven.linked_projects,
@@ -1224,7 +1224,7 @@ impl Project {
return;
}
let (roots, excludes) = (self.content_roots(), self.exclude_globs());
self.lsp.set_content_roots(language_server_roots(&self.root, roots.clone()));
self.lsp.set_content_roots(roots.clone());
self.lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
&self.root,
&self.settings.effective().languages.java.maven.linked_projects,
@@ -1369,22 +1369,6 @@ fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cac
extra_content_roots(settings, root, build_cache)
}
/// The content roots plus the projects attached inside this one. The index covers those
/// already, but each is a project of its own (a git worktree under the project, a nested
/// Cargo workspace), so its files get a language server rooted there, not at this root.
fn language_server_roots(root: &Path, mut roots: Vec<PathBuf>) -> Vec<PathBuf> {
if let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root)
&& !workspace.is_container(root)
{
for path in workspace.projects {
if path != root && path.starts_with(root) && !roots.contains(&path) {
roots.push(path);
}
}
}
roots
}
/// The roots a file may navigate into: its own root (the workspace member containing it, or
/// the project root) plus that root's configured dependencies. A workspace member depends
/// only on the roots picked per member in Project Structure › Dependencies —
@@ -2179,25 +2163,4 @@ mod content_roots_tests {
let roots = content_roots(&settings, &root, &tmp.path().join("build"));
assert_eq!(roots, vec![shared, dep]);
}
#[test]
fn projects_attached_inside_the_root_get_their_own_language_server_root() {
let tmp = tempfile::tempdir().unwrap();
let ws = dunce::canonicalize(tmp.path()).unwrap();
let (root, nested, other) = (ws.join("app"), ws.join("app/.wt/feature"), ws.join("other"));
for dir in [&nested, &other] {
std::fs::create_dir_all(dir).unwrap();
}
let settings = ide_core::settings::Settings::default();
let build = ws.join("build");
assert!(super::language_server_roots(&root, content_roots(&settings, &root, &build)).is_empty());
ide_workspace::workspace::Workspace::attach(&root, "app", vec![root.clone(), nested.clone(), other.clone()])
.unwrap();
// The index walks the nested project as part of the root ...
let roots = content_roots(&settings, &root, &build);
assert_eq!(roots, vec![other.clone()]);
// ... while its files go to a language server of its own.
assert_eq!(super::language_server_roots(&root, roots), vec![other, nested]);
}
}
+2 -26
Переглянути файл
@@ -6271,15 +6271,10 @@ fn api14_settings_and_input_events_use_other_and_capture_the_editor() {
assert!(f.host.wait_events(Duration::from_secs(5)));
let received: serde_json::Value = serde_json::from_str(&f.run("api14", "events", None).unwrap().unwrap()).unwrap();
let events = received.as_array().unwrap();
assert_eq!(events.len(), 4, "{received}");
// The first synthetic post hands over the current keys ("enabled": false);
// the second is a real diff to true. Keys come from the recomputed
// snapshot, never from the event payload ("another-plugin-key").
assert_eq!(events.len(), 3, "{received}");
assert_eq!(events[0]["kind"], "settings-changed");
assert_eq!(events[0]["data"], "[\"enabled\"]");
assert_eq!(events[1]["kind"], "settings-changed");
assert_eq!(events[1]["data"], "[\"enabled\"]");
assert_eq!(events[3]["kind"], "input-mode-changed");
assert_eq!(events[2]["kind"], "input-mode-changed");
assert_eq!(events[2]["editor"][0], path);
assert_eq!(events[2]["editor"][1][0], serde_json::json!([0, 0, 0, 0]));
}
@@ -7021,22 +7016,3 @@ fn the_language_server_grant_needs_api_1_9() {
let err = f.host.install_from_dir(&pkg, &Consent::all()).unwrap_err();
assert!(err.message.contains("new in plugin API 1.9"), "{err:?}");
}
/// The UI's synthetic post-install `SettingsChanged([])` reaches a plugin that
/// subscribes to `on-event:settings-changed`, though it carries no keys.
#[test]
fn a_freshly_installed_plugin_gets_the_post_install_settings_event() {
let f = fixture(Limits::default());
f.install(&sample("api14"));
use ide_plugin::WorkbenchEvent as E;
// What refreshEventKinds() posts right after commandsChanged (install).
f.host.post_events(Some("main"), vec![E::SettingsChanged(Vec::new())]);
f.host.flush_events_at(Instant::now() + Duration::from_secs(2));
assert!(f.host.wait_events(Duration::from_secs(5)));
let received: serde_json::Value = serde_json::from_str(&f.run("api14", "events", None).unwrap().unwrap()).unwrap();
let events = received.as_array().unwrap();
assert!(
events.iter().any(|e| e["kind"] == "settings-changed"),
"freshly installed plugin got no post-install event: {received}"
);
}
-2
Переглянути файл
@@ -33,7 +33,6 @@ const BUILTIN: &[(&str, &str)] = &[
("gdscript", include_str!("../../../languages/gdscript.toml")),
("gdshader", include_str!("../../../languages/gdshader.toml")),
("go", include_str!("../../../languages/go.toml")),
("gherkin", include_str!("../../../languages/gherkin.toml")),
("gomod", include_str!("../../../languages/gomod.toml")),
("gowork", include_str!("../../../languages/gowork.toml")),
("godot-resource", include_str!("../../../languages/godot-resource.toml")),
@@ -1058,7 +1057,6 @@ mod tests {
("CMakeLists.txt", "cmake"),
("api.proto", "proto"),
("schema.graphql", "graphql"),
("checkout.feature", "gherkin"),
("schema.prisma", "prisma"),
("main.tf", "terraform"),
("prod.tfvars", "terraform-vars"),
+18 -370
Переглянути файл
@@ -6,15 +6,11 @@
use crate::LspManager;
use crate::server::Server;
use ide_core::{CancellationToken, DocId, Pos, Range};
use ide_core::{DocId, Pos, Range};
use serde::Deserialize;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::Arc;
use std::sync::atomic::Ordering;
use std::time::Duration;
use tokio::io::AsyncReadExt;
pub(crate) const CHECK_UPGRADES: &str = "gopls.check_upgrades";
/// gopls answers code lenses once it has loaded the module.
@@ -22,43 +18,6 @@ const ATTEMPTS: u32 = 10;
const RETRY: Duration = Duration::from_secs(2);
/// Producer of the deprecation diagnostics (one full set per go.mod).
const DEPRECATIONS: &str = "go-mod-deprecations";
// This optional background check must not wait indefinitely on a proxy or toolchain download.
const QUERY_TIMEOUT: Duration = Duration::from_secs(60);
const OUTPUT_LIMIT: u64 = 8 * 1024 * 1024;
#[derive(Default)]
pub(crate) struct Queries {
generation: u64,
running: HashMap<DocId, (u64, CancellationToken)>,
}
impl Queries {
fn begin(&mut self, doc: DocId) -> (u64, CancellationToken) {
self.cancel(doc);
self.generation += 1;
let cancel = CancellationToken::new();
self.running.insert(doc, (self.generation, cancel.clone()));
(self.generation, cancel)
}
fn finish(&mut self, doc: DocId, generation: u64) {
if self.running.get(&doc).is_some_and(|(current, _)| *current == generation) {
self.running.remove(&doc);
}
}
pub(crate) fn cancel(&mut self, doc: DocId) {
if let Some((_, cancel)) = self.running.remove(&doc) {
cancel.cancel();
}
}
pub(crate) fn cancel_all(&mut self) {
for (_, (_, cancel)) in self.running.drain() {
cancel.cancel();
}
}
}
fn is_go_mod(path: &Path) -> bool {
path.file_name().is_some_and(|n| n == "go.mod")
@@ -107,15 +66,6 @@ impl LspManager {
}
async fn report_deprecated_modules(&self, doc: DocId, server: &Server) {
let (generation, cancel) = self.go_mod_queries.lock().begin(doc);
self.report_deprecated_modules_query(doc, server, &cancel).await;
self.go_mod_queries.lock().finish(doc, generation);
}
async fn report_deprecated_modules_query(&self, doc: DocId, server: &Server, cancel: &CancellationToken) {
if self.shutting_down.load(Ordering::Acquire) || !self.execution_allowed.load(Ordering::Acquire) {
return;
}
let Some((path, text)) = self.docs.lock().get(&doc).map(|d| (d.path.clone(), d.text.as_str().to_owned()))
else {
return;
@@ -128,9 +78,10 @@ impl LspManager {
let search = crate::launch::server_search_path(&config);
let Some(dir) = path.parent().map(Path::to_path_buf) else { return };
let modules: Vec<String> = required.iter().map(|r| r.path.clone()).collect();
let Some(deprecated) = list_deprecations(&dir, &search, &modules, cancel).await else { return };
let listed = tokio::task::spawn_blocking(move || list_deprecations(&dir, &search, &modules)).await;
let Ok(Some(deprecated)) = listed else { return };
// The document changed meanwhile: its own save runs again.
if cancel.is_cancelled() || self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
if self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
return;
}
let items = required
@@ -206,100 +157,22 @@ struct ListedModule {
}
/// `(module, message)` of each deprecated module in `modules`; `None` when `go` failed.
async fn list_deprecations(
dir: &Path,
search: &std::ffi::OsStr,
modules: &[String],
cancel: &CancellationToken,
) -> Option<Vec<(String, String)>> {
let (dir, search, modules) = (dir.to_path_buf(), search.to_owned(), modules.to_vec());
let command = tokio::task::spawn_blocking(move || {
let go: PathBuf = ide_core::tool_path::find_command("go", &search, &dir)?;
let mut command = Command::new(go);
command.args(["list", "-m", "-u", "-e", "-json"]).args(modules).current_dir(dir).env("PATH", search);
Some(command)
})
.await
.ok()??;
let output = run_query(command, cancel, QUERY_TIMEOUT).await?;
if output.is_empty() {
fn list_deprecations(dir: &Path, search: &std::ffi::OsStr, modules: &[String]) -> Option<Vec<(String, String)>> {
let go: PathBuf = ide_core::tool_path::find_command("go", search, dir)?;
let output = ide_core::process::prepare(&mut std::process::Command::new(go))
.args(["list", "-m", "-u", "-e", "-json"])
.args(modules)
.current_dir(dir)
.env("PATH", search)
.stdin(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.output()
.ok()?;
if output.stdout.is_empty() {
tracing::debug!("go list -m -u in {}: {}", dir.display(), output.status);
return None;
}
tokio::task::spawn_blocking(move || parse_deprecations(&output)).await.ok()
}
async fn run_query(command: Command, cancel: &CancellationToken, timeout: Duration) -> Option<Vec<u8>> {
let cancel = cancel.child_token();
let _cancel_on_drop = cancel.clone().drop_guard();
// The supervisor owns cleanup even if the caller's future is dropped.
tokio::spawn(async move { supervise_query(command, &cancel, timeout).await }).await.ok().flatten()
}
async fn supervise_query(mut command: Command, cancel: &CancellationToken, timeout: Duration) -> Option<Vec<u8>> {
if cancel.is_cancelled() {
return None;
}
ide_core::process::prepare(&mut command);
ide_core::process::own_group(&mut command);
command.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());
let mut command = tokio::process::Command::from(command);
command.kill_on_drop(true);
let mut child = command.spawn().ok()?;
#[cfg(windows)]
let job = child.id().and_then(ide_core::process::Job::for_pid);
let stdout = child.stdout.take()?;
let mut reader = tokio::spawn(async move {
let mut output = Vec::new();
stdout.take(OUTPUT_LIMIT + 1).read_to_end(&mut output).await.ok()?;
if output.len() as u64 > OUTPUT_LIMIT {
tracing::debug!("go module query exceeded stdout budget");
return None;
}
Some(output)
});
let deadline = tokio::time::sleep(timeout);
tokio::pin!(deadline);
// Drain before reaping: if a descendant holds stdout open, the root's id
// still belongs to this child when cancellation kills its process tree.
let output = tokio::select! {
biased;
() = cancel.cancelled() => None,
() = &mut deadline => {
tracing::debug!("go module query timed out");
None
},
result = &mut reader => result.ok().flatten(),
};
if let Some(bytes) = output {
let status = tokio::select! {
biased;
() = cancel.cancelled() => None,
() = &mut deadline => {
tracing::debug!("go module query timed out");
None
},
status = child.wait() => Some(status),
};
if let Some(status) = status {
return status.ok().map(|_| bytes);
}
}
// The root is still unreaped here, so its process/group id cannot be reused.
if let Some(pid) = child.id() {
let _ = tokio::task::spawn_blocking(move || {
#[cfg(windows)]
if let Some(job) = job {
job.terminate();
return;
}
ide_core::process::kill_tree_of(pid);
})
.await;
}
let _ = child.start_kill();
let _ = child.wait().await;
reader.abort();
None
Some(parse_deprecations(&output.stdout))
}
fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
@@ -314,231 +187,6 @@ fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
mod tests {
use super::*;
#[test]
fn queries_cancel_only_the_superseded_document() {
let mut queries = Queries::default();
let (first, old) = queries.begin(DocId(1));
let (_, other) = queries.begin(DocId(2));
let (second, new) = queries.begin(DocId(1));
assert!(old.is_cancelled());
assert!(!other.is_cancelled());
assert!(!new.is_cancelled());
queries.finish(DocId(1), first);
assert_eq!(queries.running.len(), 2);
queries.finish(DocId(1), second);
assert_eq!(queries.running.len(), 1);
queries.cancel_all();
assert!(other.is_cancelled());
assert!(queries.running.is_empty());
}
#[test]
fn closing_one_document_does_not_cancel_another() {
let mut queries = Queries::default();
let (_, closed) = queries.begin(DocId(1));
let (_, other) = queries.begin(DocId(2));
queries.cancel(DocId(1));
assert!(closed.is_cancelled());
assert!(!other.is_cancelled());
assert_eq!(queries.running.len(), 1);
}
#[cfg(unix)]
fn shell(script: &str) -> Command {
let mut command = Command::new("sh");
command.args(["-c", script]);
command
}
#[cfg(target_os = "linux")]
async fn assert_stopped(pid: u32) {
tokio::time::timeout(Duration::from_secs(5), async {
while let Ok(stat) = std::fs::read_to_string(format!("/proc/{pid}/stat")) {
if stat.rsplit_once(") ").unwrap().1.split_whitespace().next() == Some("Z") {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
}
#[cfg(unix)]
#[tokio::test]
async fn cancelled_query_never_spawns() {
let dir = tempfile::tempdir().unwrap();
let cancel = CancellationToken::new();
cancel.cancel();
let mut command = shell("touch started");
command.current_dir(dir.path());
assert!(run_query(command, &cancel, Duration::from_secs(5)).await.is_none());
assert!(!dir.path().join("started").exists());
}
#[cfg(unix)]
#[tokio::test]
async fn queries_keep_working_directories_and_environments_separate() {
let a = tempfile::tempdir().unwrap();
let b = tempfile::tempdir().unwrap();
std::fs::write(a.path().join("value"), "directory-a").unwrap();
std::fs::write(b.path().join("value"), "directory-b").unwrap();
let mut ca = shell("printf '%s:' \"$QUERY_VALUE\"; cat value");
ca.current_dir(a.path()).env("QUERY_VALUE", "env-a");
let mut cb = shell("printf '%s:' \"$QUERY_VALUE\"; cat value");
cb.current_dir(b.path()).env("QUERY_VALUE", "env-b");
let cancel = CancellationToken::new();
let (a, b) = tokio::join!(
run_query(ca, &cancel, Duration::from_secs(5)),
run_query(cb, &cancel, Duration::from_secs(5)),
);
assert_eq!(a.unwrap(), b"env-a:directory-a");
assert_eq!(b.unwrap(), b"env-b:directory-b");
}
#[cfg(unix)]
#[tokio::test]
async fn timeout_kills_and_reaps_the_query() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("echo $$ > pid; exec sleep 2");
command.current_dir(dir.path());
let output = run_query(command, &CancellationToken::new(), Duration::from_secs(1)).await;
assert!(output.is_none());
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap().trim().parse().unwrap();
assert!(!ide_core::process::process_alive(pid));
}
#[cfg(unix)]
#[tokio::test]
async fn cancellation_kills_the_running_query_and_its_child() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("sleep 30 & echo $$ $! > pids; wait");
command.current_dir(dir.path());
let cancel = CancellationToken::new();
let token = cancel.clone();
let task = tokio::spawn(async move { run_query(command, &token, Duration::from_secs(10)).await });
let pids = dir.path().join("pids");
tokio::time::timeout(Duration::from_secs(5), async {
while !std::fs::read_to_string(&pids).is_ok_and(|s| s.split_whitespace().count() == 2) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let text = std::fs::read_to_string(pids).unwrap();
let pids: Vec<u32> = text.split_whitespace().map(|p| p.parse().unwrap()).collect();
cancel.cancel();
assert!(task.await.unwrap().is_none());
assert!(!ide_core::process::process_alive(pids[0]));
// An orphaned child may remain a zombie until the host's init reaps it.
#[cfg(target_os = "linux")]
assert_stopped(pids[1]).await;
#[cfg(not(target_os = "linux"))]
tokio::time::timeout(Duration::from_secs(5), async {
while ide_core::process::process_alive(pids[1]) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
}
#[cfg(unix)]
#[tokio::test]
async fn dropping_the_caller_still_reaps_its_query() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("sleep 30 & echo $$ $! > pid; wait");
command.current_dir(dir.path());
let task =
tokio::spawn(async move { run_query(command, &CancellationToken::new(), Duration::from_secs(10)).await });
let file = dir.path().join("pid");
tokio::time::timeout(Duration::from_secs(5), async {
while !std::fs::read_to_string(&file).is_ok_and(|s| s.split_whitespace().count() == 2) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let text = std::fs::read_to_string(file).unwrap();
let pids: Vec<u32> = text.split_whitespace().map(|p| p.parse().unwrap()).collect();
let pid = pids[0];
task.abort();
let _ = task.await;
tokio::time::timeout(Duration::from_secs(5), async {
while ide_core::process::process_alive(pid) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
#[cfg(target_os = "linux")]
assert_stopped(pids[1]).await;
#[cfg(not(target_os = "linux"))]
tokio::time::timeout(Duration::from_secs(5), async {
while ide_core::process::process_alive(pids[1]) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
}
#[cfg(target_os = "linux")]
#[tokio::test]
async fn timeout_cleans_up_a_child_holding_stdout_after_root_exit() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("sleep 30 & echo $! > pid; exit 0");
command.current_dir(dir.path());
assert!(run_query(command, &CancellationToken::new(), Duration::from_secs(1)).await.is_none());
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap();
assert_stopped(pid.trim().parse().unwrap()).await;
}
#[cfg(unix)]
#[tokio::test]
async fn output_at_the_limit_is_not_truncated() {
let output = run_query(shell("head -c 8388608 /dev/zero"), &CancellationToken::new(), Duration::from_secs(5))
.await
.unwrap();
assert_eq!(output.len() as u64, OUTPUT_LIMIT);
}
#[cfg(unix)]
#[tokio::test]
async fn oversized_output_kills_the_query() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("echo $$ > pid; head -c 8388609 /dev/zero; exec sleep 30");
command.current_dir(dir.path());
assert!(run_query(command, &CancellationToken::new(), Duration::from_secs(5)).await.is_none());
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap().trim().parse().unwrap();
assert!(!ide_core::process::process_alive(pid));
}
#[cfg(unix)]
#[tokio::test]
async fn preserves_output_from_a_nonzero_exit() {
assert_eq!(
run_query(shell("printf partial; exit 1"), &CancellationToken::new(), Duration::from_secs(5))
.await
.unwrap(),
b"partial"
);
}
#[cfg(unix)]
#[tokio::test]
async fn failed_spawn_does_not_poison_a_following_query() {
assert!(
run_query(Command::new("/no/such/go-query"), &CancellationToken::new(), Duration::from_secs(5))
.await
.is_none()
);
assert_eq!(
run_query(shell("printf ok"), &CancellationToken::new(), Duration::from_secs(5)).await.unwrap(),
b"ok"
);
}
fn at(line: u32, from: u32, to: u32) -> Range {
Range { start: Pos { line, col: from }, end: Pos { line, col: to } }
}
-5
Переглянути файл
@@ -240,7 +240,6 @@ pub struct LspManager {
shown_messages: Mutex<HashSet<(String, String)>>,
/// go.mod files whose upgrades gopls has been asked to check this session.
go_mod_checked: Mutex<HashSet<PathBuf>>,
go_mod_queries: Mutex<go_mod::Queries>,
/// Virtual (non-`file:`) URIs a server returned, by the server that owns them.
virtual_origins: Mutex<HashMap<String, ide_core::ServerId>>,
/// Contents fetched for virtual URIs.
@@ -517,7 +516,6 @@ impl LspManager {
configuration_cache: Arc::new(Mutex::new(Default::default())),
shown_messages: Mutex::new(HashSet::new()),
go_mod_checked: Mutex::new(HashSet::new()),
go_mod_queries: Mutex::new(go_mod::Queries::default()),
virtual_origins: Mutex::new(HashMap::new()),
virtual_docs: Mutex::new(HashMap::new()),
virtual_stamps: Mutex::new(HashMap::new()),
@@ -1395,7 +1393,6 @@ impl LspManager {
}
fn close_document(&self, doc: DocId) {
self.go_mod_queries.lock().cancel(doc);
let (d, compose_removed) = {
let mut docs = self.docs.lock();
let Some(d) = docs.remove(&doc) else { return };
@@ -3716,7 +3713,6 @@ impl LspManager {
pub fn set_execution_allowed(&self, allowed: bool) {
let previous = self.execution_allowed.swap(allowed, Ordering::AcqRel);
if !allowed {
self.go_mod_queries.lock().cancel_all();
for server in self.servers.lock().iter() {
server.start_token().cancel();
}
@@ -4061,7 +4057,6 @@ impl LspManager {
pub async fn shutdown_all(&self) {
self.shutting_down.store(true, Ordering::Release);
self.go_mod_queries.lock().cancel_all();
let _reconfigure = self.reconfigure_lock.lock().await;
let servers: Vec<Arc<Server>> = self.servers.lock().clone();
join_all(servers.iter().map(|s| self.stop_instance(s, true))).await;
-2
Переглянути файл
@@ -885,8 +885,6 @@ pub fn jdk_sdk(j: &crate::java::Jdk) -> Sdk {
"JAVA_HOME"
} else if crate::java::is_downloaded(&j.home) {
"downloaded"
} else if crate::java::is_added(&j.home) {
"added"
} else {
version_managers::manager_of(&j.home).unwrap_or("system")
};
-41
Переглянути файл
@@ -138,26 +138,6 @@ pub fn add_jdk_root(dir: &Path) {
}
}
/// JDK homes added by hand (Settings › SDKs › Add JDK from Disk…).
static ADDED: Mutex<Vec<PathBuf>> = Mutex::new(Vec::new());
/// Sets the JDK homes added by hand; the next scan lists them (a change drops the cached scan).
pub fn set_added_jdks(homes: impl IntoIterator<Item = PathBuf>) {
let homes: Vec<PathBuf> = homes.into_iter().filter(|h| !h.as_os_str().is_empty()).collect();
let mut added = ADDED.lock().unwrap_or_else(|e| e.into_inner());
if *added != homes {
*added = homes;
drop(added);
*JDKS.lock().unwrap_or_else(|e| e.into_inner()) = None;
}
}
/// Whether `home` is a JDK added by hand.
pub fn is_added(home: &Path) -> bool {
let added = ADDED.lock().unwrap_or_else(|e| e.into_inner());
added.iter().any(|h| jdk_at(h).is_some_and(|j| j.home == home))
}
/// Whether `home` lies in a folder registered with [`add_jdk_root`].
pub fn is_downloaded(home: &Path) -> bool {
let roots = EXTRA_ROOTS.lock().unwrap_or_else(|e| e.into_inner());
@@ -210,7 +190,6 @@ fn scan() -> Vec<Jdk> {
for (dir, _) in ide_core::version_managers::installs(ide_core::version_managers::Tool::Java) {
homes.extend([dir.join("Contents/Home"), dir]);
}
homes.extend(ADDED.lock().unwrap_or_else(|e| e.into_inner()).iter().cloned());
let mut out: Vec<Jdk> = Vec::new();
for h in homes {
if let Some(jdk) = jdk_at(&h)
@@ -1385,26 +1364,6 @@ mod tests {
assert!(is_downloaded(&home) && !is_downloaded(Path::new("/elsewhere")));
}
#[test]
fn jdks_added_by_hand_are_listed_until_removed() {
let tmp = tempfile::tempdir().unwrap();
// A macOS bundle picked as its folder: listed by its `Contents/Home`.
let bundle = tmp.path().join("odd place/my-jdk.jdk");
let home = bundle.join("Contents/Home");
std::fs::create_dir_all(home.join("bin")).unwrap();
std::fs::write(home.join("release"), "JAVA_VERSION=\"17.0.9\"\nIMPLEMENTOR=\"Acme\"\n").unwrap();
std::fs::write(home.join("bin").join(crate::exe("java")), "").unwrap();
let home = dunce::canonicalize(&home).unwrap();
set_added_jdks([bundle.clone()]);
assert!(installed_jdks().iter().any(|j| j.home == home && j.major == 17));
assert!(is_added(&home));
let sdk = crate::jdk_sdk(&jdk_at(&bundle).unwrap());
assert_eq!((sdk.name.as_str(), sdk.source.as_str()), ("Acme 17.0.9", "added"));
set_added_jdks(Vec::new());
assert!(!installed_jdks().iter().any(|j| j.home == home));
assert!(!is_added(&home));
}
#[test]
fn jdtls_runs_on_the_chosen_server_jdk() {
let fixtures = tempfile::tempdir().unwrap();
+2 -38
Переглянути файл
@@ -1256,42 +1256,6 @@ impl Tools {
Err(IdeError::new(ErrorKind::Io, format!("pip install {package} failed ({status})")))
}
/// A command running pip, before its arguments. The interpreter's own pip when it has one;
/// a virtualenv made by uv has none, so then pip through `uv tool run`, or another Python
/// on `PATH` that has it.
fn pip_command(&self, python: PathBuf, emit: Emit) -> Command {
let has_pip = |python: &Path| {
let mut c = self.python_command(python);
c.args(["-m", "pip", "--version"]);
run_quiet(c, Duration::from_secs(20)).is_some_and(|(ok, _)| ok)
};
let module = |python: &Path| {
let mut c = self.python_command(python);
c.args(["-m", "pip"]);
c
};
if has_pip(&python) {
return module(&python);
}
let note = format!("{} has no pip", python.display());
if let Some(uv) = self.which("uv") {
emit(InstallEvent::Line { text: format!("{note}; running pip with uv") });
// pip runs in uv's own Python: the same private working directory applies.
let mut c = self.python_command(uv);
c.args(["tool", "run", "pip"]);
return c;
}
let other = ["python3", "python"]
.into_iter()
.filter_map(|name| ide_core::tool_path::find_command(name, &self.system_path, &self.root))
.find(|p| *p != python && has_pip(p));
if let Some(other) = other {
emit(InstallEvent::Line { text: format!("{note}; using {}", other.display()) });
return module(&other);
}
module(&python)
}
/// The universal (`py3-none-any`) wheel, so the copy works with every interpreter
/// version a project selects, not just the one that installed it.
fn install_pip_target(
@@ -1305,8 +1269,8 @@ impl Tools {
let _ = std::fs::remove_dir_all(&dir);
let lib = python_lib_dir(&self.root, spec.name);
std::fs::create_dir_all(&lib)?;
let mut c = self.pip_command(self.python().expect("checked"), emit);
c.args(["install", "--disable-pip-version-check", "--no-deps", "--upgrade", "--target"])
let mut c = self.python_command(self.python().expect("checked"));
c.args(["-m", "pip", "install", "--disable-pip-version-check", "--no-deps", "--upgrade", "--target"])
.arg(&lib)
.args(["--only-binary=:all:", "--platform", "any", "--implementation", "py"])
.arg(package);
-50
Переглянути файл
@@ -895,14 +895,9 @@ esac
}
}
/// Installs of one tool name share a process-wide slot: tests installing debugpy take turns.
#[cfg(unix)]
static DEBUGPY_INSTALL: parking_lot::Mutex<()> = parking_lot::Mutex::new(());
#[cfg(unix)]
#[test]
fn selected_python_is_used_for_pip_and_uv_even_with_a_versioned_filename() {
let _guard = DEBUGPY_INSTALL.lock();
let env = Env::new();
env.script(&env.sys, "python3", "exit 99");
let sdk = env._tmp.path().join("python-sdk");
@@ -940,51 +935,6 @@ exit 1
assert!(args.contains(&format!("--python {}", sdk.join("python3.14").display())), "{args}");
}
/// A virtualenv made by uv has no pip: debugpy's private copy is made with pip through uv.
#[cfg(unix)]
#[test]
fn debugpy_installs_through_uv_when_the_selected_python_has_no_pip() {
let _guard = DEBUGPY_INSTALL.lock();
let env = Env::new();
let venv = env._tmp.path().join("project/.venv/bin");
env.script(&venv, "python", "echo \"$(basename \"$0\"): No module named pip\" >&2; exit 1");
let log = env._tmp.path().join("uv.log");
env.script(
&env.sys,
"uv",
&format!(
r#"
echo "$@" >> '{log}'
while [ $# -gt 0 ]; do
if [ "$1" = "--target" ]; then
/bin/mkdir -p "$2/debugpy" "$2/debugpy-1.8.0.dist-info"
/usr/bin/touch "$2/debugpy/__init__.py"
exit 0
fi
shift
done
exit 1
"#,
log = log.display()
),
);
let tools = env.tools().with_runtime(BTreeMap::from([("python".into(), venv.join("python"))]), BTreeMap::new());
let lines = Mutex::new(Vec::new());
let info = tools
.install("debugpy", &langs(), &CancellationToken::new(), &|e| {
if let InstallEvent::Line { text } = e {
lines.lock().push(text);
}
})
.unwrap();
assert_eq!(info.status, ToolStatus::Installed);
assert_eq!(info.version.as_deref(), Some("1.8.0"));
let args = fs::read_to_string(log).unwrap();
assert!(args.starts_with("tool run pip install "), "{args}");
assert!(args.contains("--platform any"), "{args}");
assert!(lines.lock().iter().any(|l| l.contains("has no pip")));
}
#[test]
fn a_cancelled_install_leaves_the_previous_one_in_place() {
let tmp = tempfile::tempdir().unwrap();
+1 -2
Переглянути файл
@@ -1159,8 +1159,7 @@ impl Repo {
write::stage_patch(self, patch, &|path| encoding(path).map(Into::into))
}
/// Discards unstaged changes: tracked paths are restored from the index (staged
/// changes are kept), untracked files and directories are deleted. A submodule goes back
/// to the commit the index records, with its tracked files restored.
/// changes are kept), untracked files and directories are deleted.
pub fn discard(&self, paths: &[PathBuf]) -> IdeResult<()> {
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
write::discard(self, paths)
+6 -9
Переглянути файл
@@ -25,19 +25,16 @@ pub(crate) fn save(r: &Repo, message: &str) -> IdeResult<()> {
if run(r.root(), &["status", "--porcelain", "--untracked-files=no"], None)?.stdout_str().trim().is_empty() {
return Ok(());
}
let before = stash_top(r);
let before = run(r.root(), &["rev-parse", "-q", "--verify", "refs/stash"], None).map(|o| o.stdout_str()).ok();
run(r.root(), &["stash", "push", "-q", "-m", message], None)?;
// A stash that succeeds without a new entry found nothing it saves: the status above also
// lists submodules at another commit or with changes inside, which a stash leaves in place.
let Some(id) = stash_top(r).filter(|id| Some(id) != before.as_ref()) else { return Ok(()) };
std::fs::write(marker, id)?;
let id = run(r.root(), &["rev-parse", "refs/stash"], None)?.stdout_str();
if before.as_deref().map(str::trim) == Some(id.trim()) {
return Err(IdeError::invalid("could not save the local changes"));
}
std::fs::write(marker, id.trim())?;
Ok(())
}
fn stash_top(r: &Repo) -> Option<String> {
run(r.root(), &["rev-parse", "-q", "--verify", "refs/stash"], None).ok().map(|o| o.stdout_str().trim().to_owned())
}
/// Brings the saved changes back once no operation is in progress. Fails when they come
/// back with conflicts (they then also stay in the stash).
pub(crate) fn restore(r: &Repo) -> IdeResult<()> {
+6 -17
Переглянути файл
@@ -391,24 +391,18 @@ pub(crate) fn discard(r: &Repo, paths: &[PathBuf]) -> IdeResult<()> {
let rel = r.rel_paths(paths)?;
// `git restore --worktree` refuses unmerged paths: roll those back to HEAD first.
discard_unmerged(r, &rel)?;
let (mut tracked, mut untracked, mut submodules) = (Vec::new(), Vec::new(), Vec::new());
let (mut tracked, mut untracked) = (Vec::new(), Vec::new());
{
let repo = r.gix()?;
let index = repo.index_or_empty().map_err(gx)?;
for p in rel {
let exact = index.entry_index_by_path(BStr::new(p.as_bytes())).ok().map(|i| &index.entries()[i]);
let exact = index.entry_index_by_path(BStr::new(p.as_bytes())).is_ok();
let dir_prefix = if p == "." { String::new() } else { format!("{}/", p.trim_end_matches('/')) };
let children = index.prefixed_entries(BStr::new(dir_prefix.as_bytes()));
if let Some(entry) = exact {
if entry.mode.is_submodule() {
submodules.push(p);
} else {
tracked.push(p);
}
let has_tracked_children = index.prefixed_entries(BStr::new(dir_prefix.as_bytes())).is_some();
if exact {
tracked.push(p);
} else if r.abs_path(&p).is_dir() {
if let Some(children) = children {
submodules
.extend(children.iter().filter(|e| e.mode.is_submodule()).map(|e| e.path(&index).to_string()));
if has_tracked_children {
tracked.push(p.clone());
}
untracked.push(p);
@@ -418,11 +412,6 @@ pub(crate) fn discard(r: &Repo, paths: &[PathBuf]) -> IdeResult<()> {
}
}
run_paths(r, &["restore", "--worktree"], &tracked)?;
// A plain restore leaves a submodule alone. This one checks out the commit the index
// records there and restores its tracked files, keeping its untracked ones.
if crate::execution_allowed() {
run_paths(r, &["restore", "--recurse-submodules", "--worktree"], &submodules)?;
}
if !untracked.is_empty() {
// `git clean` keeps ignored files and refuses paths outside the worktree.
run_paths(r, &["clean", "-f", "-d", "-q"], &untracked)?;
+1 -69
Переглянути файл
@@ -69,8 +69,7 @@ impl Fixture {
fn push_from_other(&self, bare: &Path, rel: &str, content: &str) {
let other = self.tmp.path().join(format!("other-{}", rel.replace('/', "_")));
if !other.exists() {
let (bare, other_dir) = (bare.to_str().unwrap(), other.to_str().unwrap());
git_in(self.tmp.path(), &["clone", "-q", "-c", "core.autocrlf=false", bare, other_dir]);
git_in(self.tmp.path(), &["clone", "-q", bare.to_str().unwrap(), other.to_str().unwrap()]);
configure(&other);
}
git_in(&other, &["pull", "-q", "--rebase"]);
@@ -637,73 +636,6 @@ fn update_with_rebase_keeps_a_file_added_then_deleted_added_to_the_index() {
assert!(fx.git(&["status", "--porcelain", "--", "ad.txt"]).starts_with('A'), "still added");
}
/// Submodules `dirty` and `moved` (each with commits "one" and "two", at "two") committed in
/// the clone of [`Fixture::with_origin`] and pushed; then `dirty` gets an uncommitted edit of a
/// tracked file plus an untracked file, and `moved` is checked out at "one". Returns the commit
/// the superproject records for `moved`.
fn with_changed_submodules(fx: &Fixture) -> String {
for name in ["dirty", "moved"] {
let lib = fx.tmp.path().join(format!("lib-{name}"));
std::fs::create_dir(&lib).unwrap();
git_in(&lib, &["init", "-q"]);
configure(&lib);
std::fs::write(lib.join("f.txt"), "one\n").unwrap();
git_in(&lib, &["add", "-A"]);
git_in(&lib, &["commit", "-q", "-m", "one"]);
std::fs::write(lib.join("f.txt"), "two\n").unwrap();
git_in(&lib, &["commit", "-q", "-am", "two"]);
let url = lib.to_str().unwrap();
fx.git(&["-c", "protocol.file.allow=always", "-c", "core.autocrlf=false", "submodule", "add", "-q", url, name]);
configure(&fx.path(name));
}
fx.commit_all("submodules");
fx.git(&["push", "-q", "origin", "main"]);
let recorded = git_in(&fx.path("moved"), &["rev-parse", "HEAD"]);
fx.write("dirty/f.txt", "edited\n");
fx.write("dirty/untracked.txt", "u\n");
git_in(&fx.path("moved"), &["checkout", "-q", "HEAD~1"]);
recorded
}
/// git lists submodules at another commit or with changes inside among the superproject's
/// changes, but its stash leaves them in place, so Update Project has nothing to put aside (#3632).
#[test]
fn update_with_changed_submodules_and_no_other_local_changes() {
for (rebase, earlier_stash) in [(false, false), (false, true), (true, false), (true, true)] {
let (fx, bare) = Fixture::with_origin();
let recorded = with_changed_submodules(&fx);
if earlier_stash {
fx.write("a.txt", "stashed\n");
fx.git(&["stash", "push", "-q", "-m", "earlier"]);
}
fx.push_from_other(&bare, "remote.txt", "r\n");
let repo = fx.repo();
let (cancel, out) = quiet();
repo.pull(rebase, &cancel, &out).unwrap_or_else(|e| panic!("rebase={rebase} stash={earlier_stash}: {e}"));
assert!(fx.exists("remote.txt"));
assert_eq!(fx.read("dirty/f.txt"), "edited\n");
assert_ne!(git_in(&fx.path("moved"), &["rev-parse", "HEAD"]), recorded);
let stashes = fx.git(&["stash", "list"]);
assert_eq!(stashes.lines().count(), usize::from(earlier_stash), "{stashes}");
assert!(!fx.dir.join(".git/openidea-saved-changes").exists());
}
}
#[test]
fn rollback_changed_submodules_restores_the_recorded_commit_and_tracked_files() {
for whole_root in [false, true] {
let (fx, _bare) = Fixture::with_origin();
let recorded = with_changed_submodules(&fx);
let repo = fx.repo();
let paths = if whole_root { vec![fx.dir.clone()] } else { vec![fx.path("dirty"), fx.path("moved")] };
repo.discard(&paths).unwrap();
assert_eq!(fx.read("dirty/f.txt"), "two\n", "whole_root={whole_root}");
assert_eq!(git_in(&fx.path("moved"), &["rev-parse", "HEAD"]), recorded);
assert_eq!(fx.read("dirty/untracked.txt"), "u\n", "untracked files of a submodule are kept");
assert_eq!(fx.git(&["status", "--porcelain", "--ignore-submodules=untracked"]), "");
}
}
#[test]
fn reset_to_the_remote_branch_drops_local_commits_and_keeps_local_changes() {
let (fx, bare) = Fixture::with_origin();
+3 -95
Переглянути файл
@@ -140,6 +140,9 @@ pub fn detect(root: &Path) -> Vec<SourceFolder> {
}
let found: Vec<String> = out[before..].iter().map(|r| r.path.clone()).collect();
for name in dirs {
if name.starts_with('.') || SKIP_DIRS.contains(&name.as_str()) {
continue;
}
let child = join(&rel, &name);
// Roots are not searched for nested modules (`src/main/java` can be huge).
if found.iter().any(|f| *f == child || f.is_empty() && name == "src") {
@@ -152,11 +155,6 @@ pub fn detect(root: &Path) -> Vec<SourceFolder> {
}
continue;
}
// Skipping discovery is not an exclusion: marked hidden/conventional
// environments still need an explicit root for index and watcher filtering.
if name.starts_with('.') || SKIP_DIRS.contains(&name.as_str()) {
continue;
}
queue.push_back((child, depth + 1));
}
}
@@ -574,96 +572,6 @@ mod tests {
assert!(affects_roots(Path::new("code10/pyvenv.cfg")));
}
#[test]
fn marked_environments_are_detected_before_name_based_walk_skips() {
let dir = tree(&[
".venv/pyvenv.cfg",
".venv/Lib/site-packages/pkg/setup.py",
".conda/conda-meta/history",
"venv/pyvenv.cfg",
"nested/.custom/pyvenv.cfg",
"nested/.custom/lib/pkg/pyproject.toml",
"build/business.go",
"bin/business.go",
"env/business.go",
"dist/business.go",
".ordinary/setup.py",
]);
assert_eq!(
summary(&detect(dir.path())),
vec![
"[email protected]/conda-meta",
"[email protected]/pyvenv.cfg",
"nested/.custom=Excluded@nested/.custom/pyvenv.cfg",
"venv=Excluded@venv/pyvenv.cfg",
]
);
}
#[test]
fn marked_environment_detection_preserves_source_roots_and_user_overrides() {
let dir = tree(&["Cargo.toml", "src/pyvenv.cfg", ".venv/pyvenv.cfg", ".conda/conda-meta/history"]);
let detected = detect(dir.path());
assert!(detected.iter().any(|r| r.path == ".venv" && r.kind == RootKind::Excluded));
assert!(detected.iter().any(|r| r.path == "src" && r.kind == RootKind::Source));
let settings = ide_core::settings::ProjectStructureSettings {
source_roots: vec![".venv".into()],
unmarked: vec![".conda".into()],
..Default::default()
};
let effective = super::super::ProjectRoots::compute(detected, &settings);
assert!(effective.excluded_globs().is_empty());
assert_eq!(effective.root_for(".venv/app.py").unwrap().kind, RootKind::Source);
}
#[test]
fn environment_markers_require_the_expected_file_type_and_respect_walk_boundaries() {
let dir = tree(&[
"pyvenv.cfg",
"app.py",
".not_venv/pyvenv.cfg/",
".not_conda/conda-meta",
".hidden/nested/pyvenv.cfg",
"a/b/c/d/e/f/g/pyvenv.cfg",
"at/b/c/d/e/f/pyvenv.cfg",
]);
// An environment opened as the project remains browsable. Hidden parents and
// the existing depth budget are not traversed to discover more environments.
assert_eq!(summary(&detect(dir.path())), vec!["at/b/c/d/e/f=Excluded@at/b/c/d/e/f/pyvenv.cfg"]);
}
#[test]
fn detected_environment_roots_prune_vfs_walk_without_hiding_business_directories() {
let dir = tree(&[
".venv/pyvenv.cfg",
".venv/Lib/site-packages/pkg/setup.py",
"internal/build/build.go",
"env/business.go",
"bin/business.go",
"dist/business.go",
"service/go.mod",
]);
for i in 0..128 {
fs::write(dir.path().join(format!(".venv/Lib/site-packages/pkg/dep{i}.py")), "").unwrap();
}
let walk = |excludes: &[String]| {
let files = std::sync::Mutex::new(Vec::new());
ide_vfs::walk_files(dir.path(), excludes, |path| {
files.lock().unwrap().push(path.strip_prefix(dir.path()).unwrap().to_owned());
});
let mut files = files.into_inner().unwrap();
files.sort();
files
};
let before = walk(&[]);
let roots = super::super::ProjectRoots::compute(detect(dir.path()), &Default::default());
let after = walk(&roots.excluded_globs());
assert_eq!(before.len(), 135);
assert_eq!(after.len(), 5);
assert_eq!(after, before.into_iter().filter(|p| !p.starts_with(".venv")).collect::<Vec<_>>());
assert_eq!(roots.root_for("service/go.mod").unwrap().kind, RootKind::Source);
}
#[test]
fn first_ecosystem_wins_for_a_shared_folder() {
// A Gradle build with a frontend: `build` stays Gradle's, `src` is not a Node root.
+8 -60
Переглянути файл
@@ -441,26 +441,13 @@ impl SettingsStore {
#[serde(rename_all = "camelCase")]
pub struct JetBrainsSettings {
pub entries: Vec<String>,
/// Entry name → text, for the files OpenIDEA reads: `colors/*.icls`, `keymaps/*.xml`,
/// `codestyles/*.xml` and some of `options/`.
/// Entry name → text, for `colors/*.icls` and the `options/*.xml` files OpenIDEA reads.
pub files: BTreeMap<String, String>,
}
const JETBRAINS_MARKER: &str = "IntelliJ IDEA Global Settings";
const JETBRAINS_OPTIONS: [&str; 9] = [
"options/editor-font.xml",
"options/terminal-font.xml",
"options/colors.scheme.xml",
"options/code.style.schemes.xml",
"options/editor.xml",
"options/ide.general.xml",
// The active keymap is stored per operating system.
"options/mac/keymap.xml",
"options/windows/keymap.xml",
"options/linux/keymap.xml",
];
/// Folders whose files are all read: (folder, extension).
const JETBRAINS_READ_DIRS: [(&str, &str); 3] = [("colors/", ".icls"), ("keymaps/", ".xml"), ("codestyles/", ".xml")];
const JETBRAINS_OPTIONS: [&str; 4] =
["options/editor-font.xml", "options/colors.scheme.xml", "options/editor.xml", "options/ide.general.xml"];
const JETBRAINS_MAX_TEXT: u64 = 4 << 20;
/// The settings of a JetBrains IDE: an exported `settings.zip`, or the IDE's own settings folder
@@ -471,23 +458,11 @@ pub fn read_jetbrains_settings(path: &Path) -> IdeResult<JetBrainsSettings> {
fn is_mapped_jetbrains_file(name: &str) -> bool {
JETBRAINS_OPTIONS.contains(&name)
|| JETBRAINS_READ_DIRS
.iter()
.any(|(dir, ext)| name.strip_prefix(dir).is_some_and(|n| !n.contains('/') && n.ends_with(ext)))
|| name.strip_prefix("colors/").is_some_and(|n| !n.contains('/') && n.ends_with(".icls"))
}
/// Folders of the settings folder whose files are listed (their names say what the user customised).
const JETBRAINS_LISTED_DIRS: [&str; 9] = [
"options",
"options/mac",
"options/windows",
"options/linux",
"colors",
"keymaps",
"codestyles",
"templates",
"inspection",
];
const JETBRAINS_LISTED_DIRS: [&str; 6] = ["options", "colors", "keymaps", "codestyles", "templates", "inspection"];
fn read_jetbrains_folder(dir: &Path) -> IdeResult<JetBrainsSettings> {
use std::io::Read;
@@ -961,25 +936,11 @@ mod tests {
("options/editor-font.xml", "<application/>"),
("options/vcs.xml", "<application/>"),
("keymaps/macOS.xml", "<keymap/>"),
("keymaps/nested/ignored.xml", "<keymap/>"),
("codestyles/Default.xml", "<code_scheme/>"),
("options/mac/keymap.xml", "<application/>"),
("options/terminal-font.xml", "<application/>"),
],
);
let read = read_jetbrains_settings(&ok).unwrap();
assert_eq!(read.entries.len(), 9);
assert_eq!(
read.files.keys().collect::<Vec<_>>(),
[
"codestyles/Default.xml",
"colors/_@user_Darcula.icls",
"keymaps/macOS.xml",
"options/editor-font.xml",
"options/mac/keymap.xml",
"options/terminal-font.xml"
]
);
assert_eq!(read.entries.len(), 5);
assert_eq!(read.files.keys().collect::<Vec<_>>(), ["colors/_@user_Darcula.icls", "options/editor-font.xml"]);
assert!(read_jetbrains_settings(&write("other.zip", &[("options/editor.xml", "")])).is_err());
std::fs::write(tmp.path().join("plain.zip"), "not a zip").unwrap();
assert!(read_jetbrains_settings(&tmp.path().join("plain.zip")).is_err());
@@ -998,31 +959,18 @@ mod tests {
put("colors/nested/ignored.icls", "<scheme/>");
put("options/editor-font.xml", "<application/>");
put("options/vcs.xml", "<application/>");
put("options/mac/keymap.xml", "<application/>");
put("keymaps/macOS.xml", "<keymap/>");
put("codestyles/Default.xml", "<code_scheme/>");
put("plugins/Tools/lib/tools.jar", "jar");
let read = read_jetbrains_settings(&config).unwrap();
assert_eq!(
read.files.keys().collect::<Vec<_>>(),
[
"codestyles/Default.xml",
"colors/_@user_Darcula.icls",
"keymaps/macOS.xml",
"options/editor-font.xml",
"options/mac/keymap.xml"
]
);
assert_eq!(read.files.keys().collect::<Vec<_>>(), ["colors/_@user_Darcula.icls", "options/editor-font.xml"]);
assert_eq!(
read.entries,
[
"options/editor-font.xml",
"options/vcs.xml",
"options/mac/keymap.xml",
"colors/_@user_Darcula.icls",
"keymaps/macOS.xml",
"codestyles/Default.xml",
"installed.txt"
]
);
-83
Переглянути файл
@@ -819,86 +819,3 @@ test("keeps ordered, bulleted and task list markers unclipped inside measured ro
expect(cb.offsetFromRowLeft).toBeGreaterThanOrEqual(0);
}
});
test("indents process-run thoughts and tool calls clearly and aligns output-less tool icons", async ({ page }) => {
await openReply(page, "All checks passed.");
await page.evaluate(async (task) => {
const storePath = "/src/features/agents/store.ts";
const store = await import(storePath);
store.useAgents.setState({
tasks: new Map([[task.id, { ...task, status: "running" as const }]]),
entries: new Map([
[
task.id,
[
{ type: "thought", text: "**Checking CI Status**\n\nInspecting workflow runs." },
{
type: "tool",
id: "t1",
title: "gh pr checks 3631 --repo l0ng-ai/openidea",
kind: "execute",
status: "completed",
locations: [],
output: "All checks pending",
diffs: [],
},
{ type: "thought", text: "**Tracking Continuous Integration**\n\nWaiting for E2E." },
{
type: "tool",
id: "t2",
title: "read_bash",
kind: "other",
status: "completed",
locations: [],
output: "E2E pass",
diffs: [],
},
{
type: "tool",
id: "t3",
title: "read_bash",
kind: "other",
status: "running",
locations: [],
output: "",
diffs: [],
},
],
],
]),
});
store.openTaskInEditorLocation(task.id);
}, TASK);
const stream = page.locator("[class*='_stream_']:visible");
const summary = stream.locator("[class*='_processSummary_']").first();
await summary.click();
await expect(stream.getByText("Checking CI Status")).toBeVisible();
const layout = await stream.evaluate((root) => {
const summaryChevron = root.querySelector<SVGElement>("[class*='_processChevron_']")!.getBoundingClientRect();
const processBody = root.querySelector<HTMLElement>("[class*='_processBody_']")!.getBoundingClientRect();
const thoughtChevron = root.querySelector<SVGElement>("[class*='_thoughtChevron_']")!.getBoundingClientRect();
const toolRows = [...root.querySelectorAll<HTMLElement>("[class*='_tool_']")];
const expandableToolChevron = toolRows[0]!
.querySelector<SVGElement>("[class*='_toolChevron_']")!
.getBoundingClientRect();
const completedReadIcon = [...toolRows[1]!.querySelectorAll("svg")].at(-1)!.getBoundingClientRect();
const runningReadIcon = toolRows[2]!.querySelector("svg")!.getBoundingClientRect();
return {
summaryChevronCenter: summaryChevron.left + summaryChevron.width / 2,
guideLeft: processBody.left,
summaryToThoughtIndent: thoughtChevron.left - summaryChevron.left,
thoughtToToolIndent: expandableToolChevron.left - thoughtChevron.left,
iconLeftDiff: Math.abs(completedReadIcon.left - runningReadIcon.left),
};
});
// Guide line drops from the center of the process summary chevron.
expect(Math.abs(layout.guideLeft - layout.summaryChevronCenter)).toBeLessThanOrEqual(1.5);
// Thoughts indent clearly inside the process run, and tool calls indent under their thought step.
expect(layout.summaryToThoughtIndent).toBeGreaterThanOrEqual(20);
expect(layout.thoughtToToolIndent).toBeGreaterThanOrEqual(14);
// Output-less running tool rows align their kind icon with expandable tool rows.
expect(layout.iconLeftDiff).toBeLessThanOrEqual(1);
});
-43
Переглянути файл
@@ -1,43 +0,0 @@
import { EditorView } from "@codemirror/view";
import { commands, type InlayHint, type Range } from "../src/platform/ipc";
import { setInvokeRoute } from "../src/platform/tauriCore";
import { lspDoc } from "../src/editor/lsp/lsp";
import { inlayExtension } from "../src/editor/lsp/inlay";
import { lspTheme } from "../src/editor/lsp/theme";
const requests: { range: Range; resolve: (hints: InlayHint[]) => void }[] = [];
setInvokeRoute(() => null);
commands.lspInlayHints = async (_doc, range) =>
new Promise((resolve) => requests.push({ range, resolve: (data) => resolve({ status: "ok", data }) }));
const view = new EditorView({
parent: document.body,
doc: Array.from({ length: 2000 }, (_, i) => `let item${i} = value;`).join("\n"),
extensions: [
EditorView.theme({ "&": { height: "400px" }, ".cm-scroller": { overflow: "auto" } }),
lspTheme,
lspDoc.of({ doc: 1, path: "demo.rs", language: "rust", uiMode: "Rust", readOnly: false }),
inlayExtension(),
],
});
Object.assign(window, {
inlayTest: {
count: () => requests.length,
resolve(index: number) {
const request = requests[index]!;
request.resolve([
{
position: { line: request.range.start.line + 1, col: 4 },
label: `hint-${index}`,
kind: "type",
paddingLeft: false,
paddingRight: false,
tooltip: null,
parts: [],
},
]);
},
destroy: () => view.destroy(),
},
});
-9
Переглянути файл
@@ -1,9 +0,0 @@
<!doctype html>
<html>
<head>
<meta charset="UTF-8" />
</head>
<body>
<script type="module" src="./inlayRequests.fixture.ts"></script>
</body>
</html>
-18
Переглянути файл
@@ -1,18 +0,0 @@
import { expect, test } from "@playwright/test";
type Probe = { count(): number; resolve(index: number): void };
test("scrolling does not let an old viewport response replace current inlay hints", async ({ page }) => {
await page.goto("/e2e/inlayRequests.html");
const count = () => page.evaluate(() => (window as unknown as { inlayTest: Probe }).inlayTest.count());
await expect.poll(count).toBe(1);
await page.locator(".cm-scroller").evaluate((el) => {
el.scrollTop = 12000;
});
await expect.poll(count).toBe(2);
await page.evaluate(() => (window as unknown as { inlayTest: Probe }).inlayTest.resolve(1));
await expect(page.locator(".cm-lsp-inlay")).toHaveText("hint-1");
await page.evaluate(() => (window as unknown as { inlayTest: Probe }).inlayTest.resolve(0));
await page.waitForTimeout(500);
await expect(page.locator(".cm-lsp-inlay")).toHaveText("hint-1");
});
-6
Переглянути файл
@@ -1,6 +0,0 @@
id = "gherkin"
name = "Gherkin"
extensions = ["feature"]
line-comment = "#"
indent = { tab-size = 2, insert-spaces = true }
ui-mode = "Gherkin"
-4
Переглянути файл
@@ -36,10 +36,6 @@ body,
opacity: 0;
pointer-events: none;
}
/* A question asked while the window opens (Trust Project?) shows over the splash (platform/splash.ts). */
.splash.splash-under-dialogs {
z-index: calc(var(--z-dialog, 900) - 1);
}
:root[data-theme^="dark"] .splash {
color: var(--fg-muted, var(--boot-fg, #8c8f95));
}
-1
Переглянути файл
@@ -489,7 +489,6 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
sdk::sdk_python_interpreter,
sdk::sdk_python_effective,
sdk::sdk_php_effective,
sdk::sdk_jdk_at,
sdk::sdk_container_python,
sdk::sdk_container_python_refresh,
sdk::sdk_php_xdebug,
-7
Переглянути файл
@@ -17,13 +17,6 @@ pub async fn sdk_detect(window: Window, state: State<'_, AppState>, kind: SdkKin
ide_host::ops::sdk::sdk_detect(&state.host, window.label(), kind).await
}
/// The JDK whose home is `path`, as the SDK list shows it; `None` when it is no JDK home.
#[tauri::command]
#[specta::specta]
pub async fn sdk_jdk_at(path: String) -> IdeResult<Option<Sdk>> {
ide_host::ops::sdk::sdk_jdk_at(path).await
}
/// The Python interpreters of the recently opened projects, each with its project.
#[tauri::command]
#[specta::specta]
+1 -7
Переглянути файл
@@ -330,13 +330,7 @@ pub fn menu_model(app: AppHandle, state: State<'_, AppState>, menu_state: State<
/// disabled in place (no rebuild).
#[tauri::command]
#[specta::specta]
pub fn menu_set_disabled(window: WebviewWindow, app: AppHandle, menu_state: State<'_, MenuState>, ids: Vec<String>) {
// The window whose menu runs: a project window also while its Settings window is focused.
if menu::native_menu_bar()
&& windows::target_window(&app).is_some_and(|target| !owns_menu_config(window.label(), target.label()))
{
return;
}
pub fn menu_set_disabled(app: AppHandle, menu_state: State<'_, MenuState>, ids: Vec<String>) {
let disabled: std::collections::HashSet<String> = ids.into_iter().collect();
if *menu_state.disabled.lock() == disabled {
return;
+14 -13
Переглянути файл
@@ -373,24 +373,25 @@ pub(crate) fn dispatch_menu_action(app: &tauri::AppHandle, id: &str) {
let Some(route) = menu::route(&menu::spec(menu::Os::current()), id) else { return };
match windows::target_window(app) {
Some(w) => {
// The window to bring back to the front once what the action shows is closed (Settings).
let mut return_to = None;
let label = match windows::menu_destination(w.label(), &route.action) {
windows::MenuDestination::Own => w.label(),
windows::MenuDestination::Parent { label, raise } => {
if raise && let Some(parent) = app.get_webview_window(label) {
windows::focus(&parent);
return_to = Some(w.label());
}
label
// App-level items of an auxiliary window go to its project window. Settings is modal for it:
// nothing else gets through. Others handle their own items; Close Tab closes the window.
let label = match windows::auxiliary(w.label()) {
Some((_, parent))
if matches!(
route.action.as_str(),
"app.quit" | "file.settings" | "file.projectStructure" | "file.newProjectsSettings"
) =>
{
parent
}
windows::MenuDestination::Close => {
Some((kind, _)) if kind.modal() => return,
Some(_) if route.action == "editor.closeTab" => {
let _ = w.close();
return;
}
_ => w.label(),
};
let event = menu::MenuEvent { route: &route, return_to };
if let Err(e) = app.emit_to(label, menu::MENU_EVENT, &event) {
if let Err(e) = app.emit_to(label, menu::MENU_EVENT, &route) {
tracing::warn!("failed to deliver menu event {id}: {e}");
}
}
-11
Переглянути файл
@@ -904,17 +904,6 @@ pub struct MenuRoute {
pub arg: Option<String>,
}
/// Payload of [`MENU_EVENT`]: the route, and the window that was in front when the item was
/// chosen if the action runs in another one (a Settings window's project window).
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MenuEvent<'a> {
#[serde(flatten)]
pub route: &'a MenuRoute,
#[serde(skip_serializing_if = "Option::is_none")]
pub return_to: Option<&'a str>,
}
/// Maps a clicked item id to the action to run. `None` for ids that are not
/// IDE items (native roles, placeholders).
pub fn route(spec: &[Entry], id: &str) -> Option<MenuRoute> {
+2 -51
Переглянути файл
@@ -360,8 +360,8 @@ impl AuxKind {
self != AuxKind::Settings
}
/// Has no actions of its own: menu items run in its project window.
fn runs_menu_in_parent(self) -> bool {
/// Modal for its parent: menu items other than app-level ones are dropped.
pub fn modal(self) -> bool {
self == AuxKind::Settings
}
@@ -386,34 +386,6 @@ pub fn auxiliary(label: &str) -> Option<(AuxKind, &str)> {
})
}
/// Where a menu item chosen while window `label` is focused runs.
#[derive(Debug, PartialEq, Eq)]
pub enum MenuDestination<'a> {
/// The window's own frontend.
Own,
/// The project window `label`; `raise` brings it to the front so what the action shows is seen.
Parent { label: &'a str, raise: bool },
/// The window itself is the tab: Close Tab closes it.
Close,
}
/// Actions an auxiliary window always leaves to its project window.
const PARENT_ACTIONS: [&str; 4] = ["app.quit", "file.settings", "file.projectStructure", "file.newProjectsSettings"];
/// Where menu item `action` runs while window `label` is focused. As in IDEA, the menu stays usable
/// with Settings open: it runs in the project window, whose enablement (no focused editor) the menu shows.
pub fn menu_destination<'a>(label: &'a str, action: &str) -> MenuDestination<'a> {
match auxiliary(label) {
None => MenuDestination::Own,
Some((_, parent)) if PARENT_ACTIONS.contains(&action) => {
MenuDestination::Parent { label: parent, raise: false }
}
Some((kind, parent)) if kind.runs_menu_in_parent() => MenuDestination::Parent { label: parent, raise: true },
Some(_) if action == "editor.closeTab" => MenuDestination::Close,
Some(_) => MenuDestination::Own,
}
}
/// The project window an auxiliary window belongs to (`settings-main` → `main`).
pub fn auxiliary_parent(label: &str) -> Option<&str> {
auxiliary(label).map(|(_, parent)| parent)
@@ -2377,27 +2349,6 @@ mod tests {
assert_eq!(sorted_labels(labels.into_iter().filter(|l| auxiliary_parent(l).is_none())), ["main", "project-2"]);
}
#[test]
fn menu_items_chosen_in_settings_run_in_its_project_window() {
use MenuDestination::*;
for (label, action, expected) in [
("main", "app.about", Own),
("main", "editor.closeTab", Own),
// #3625: Settings has no actions of its own; the rest of the menu runs in the project window.
("settings-main", "app.checkForUpdates", Parent { label: "main", raise: true }),
("settings-project-2", "file.newFile", Parent { label: "project-2", raise: true }),
("settings-main", "editor.closeTab", Parent { label: "main", raise: true }),
("settings-main", "file.settings", Parent { label: "main", raise: false }),
("settings-main", "app.quit", Parent { label: "main", raise: false }),
("comparison-main-0", "app.quit", Parent { label: "main", raise: false }),
("comparison-main-0", "editor.closeTab", Close),
("diff-main-1", "vcs.diff.next", Own),
("deployment-main", "app.about", Own),
] {
assert_eq!(menu_destination(label, action), expected, "{label} {action}");
}
}
#[test]
fn settings_bounds_fit_current_work_area() {
for (parent, size, work, expected) in [
-1
Переглянути файл
@@ -513,7 +513,6 @@ scaffold_requirements always project_host bin
sdk_container_python trusted project_host bindings sync
sdk_container_python_refresh trusted project_host bindings async
sdk_detect trusted project_host bindings async
sdk_jdk_at trusted project_host bindings async
sdk_locate_tools trusted project_host bindings async
sdk_php_composer_install trusted project_host bindings async
sdk_php_effective trusted project_host bindings sync
+1 -29
Переглянути файл
@@ -1096,26 +1096,6 @@ export const commands = {
sdkPythonEffective: (near: string | null) => typedError<string | null, IdeError>(__TAURI_INVOKE("sdk_python_effective", { near })),
/** The PHP interpreter chosen in Settings › Languages & Frameworks › PHP; `None`: the `php` on `PATH`. */
sdkPhpEffective: () => typedError<string | null, IdeError>(__TAURI_INVOKE("sdk_php_effective")),
/** The JDK whose home is `path`, as the SDK list shows it; `None` when it is no JDK home. */
sdkJdkAt: (path: string) => typedError<{
/**
* Executable (`python`, `node`, `pnpm`) or directory (Rust toolchain bin
* dir, GOROOT, TypeScript `lib` dir) that the setting stores.
*/
path: IpcPath,
/** Display name, e.g. `Python 3.12 (.venv)` or `stable-aarch64-apple-darwin`. */
name: string,
version: string | null,
/**
* Where it was found: `venv` | `system` | `pyenv` | `conda` | `uv` | `nvm` |
* `rustup` | `bundled` | `workspace` | `path` …
*/
source: string,
/** Environment / toolchain root (virtualenv dir, rustup toolchain dir, GOROOT). */
home: IpcPath | null,
/** Rust standard library sources, Go default GOPATH. */
extra: IpcPath | null,
} | null, IdeError>(__TAURI_INVOKE("sdk_jdk_at", { path })),
/** The project interpreter when it is a Docker or Compose run target's, with its snapshot. */
sdkContainerPython: () => typedError<{
/** The run target's id. */
@@ -6740,11 +6720,6 @@ export type JavaSettings = {
jdtlsVmArgs?: string,
/** Share one JDT LS across builds in an ordinary project window; other windows remain separate. */
jdtlsShared?: boolean,
/**
* JDK homes added by hand (Platform Settings › SDKs › Add JDK from Disk…), listed with the
* detected ones.
*/
addedJdks?: string[],
/** Build Tools › Maven. */
maven?: MavenSettings,
/** Build Tools › Gradle. */
@@ -6773,10 +6748,7 @@ export type JdkVendor = {
*/
export type JetBrainsSettings = {
entries: string[],
/**
* Entry name → text, for the files OpenIDEA reads: `colors/*.icls`, `keymaps/*.xml`,
* `codestyles/*.xml` and some of `options/`.
*/
/** Entry name → text, for `colors/*.icls` and the `options/*.xml` files OpenIDEA reads. */
files: { [key in string]: string },
};
+1 -2
Переглянути файл
@@ -134,8 +134,7 @@ class LensWidget extends WidgetType {
const guides = this.inline
? null
: guideVars(Math.floor(this.indent / this.indentUnit), this.indentUnit, this.rainbow);
if (!this.inline)
dom.style.paddingLeft = `calc(${LINE_INSET}px + ${this.indent} * var(--openidea-space, ${view.defaultCharacterWidth}px))`;
if (!this.inline) dom.style.paddingLeft = `${Math.round(this.indent * view.defaultCharacterWidth) + LINE_INSET}px`;
if (guides) {
dom.style.setProperty("--openidea-guide-images", guides.images);
dom.style.setProperty("--openidea-guide-positions", guides.positions);
-44
Переглянути файл
@@ -1,44 +0,0 @@
import { foldable } from "@codemirror/language";
import { EditorState } from "@codemirror/state";
import { describe, expect, it } from "vitest";
import { gherkinSupport } from "./gherkin";
const DOC = `@smoke
Feature: Checkout
As a shopper
Background:
Given a cart
Scenario Outline: pay with <method>
When I pay with "<method>":
| amount |
| 10 |
Then I see:
"""
Thanks
"""
Examples:
| method |
| card |
`;
describe("Gherkin", () => {
const state = EditorState.create({ doc: DOC, extensions: gherkinSupport() });
const foldAt = (lineText: string) => {
const line = state.doc.line(DOC.split("\n").findIndex((l) => l.trim() === lineText) + 1);
const r = foldable(state, line.from, line.to);
return r ? state.doc.lineAt(r.to).text.trim() : null;
};
it("folds sections, step arguments and doc strings by indentation", () => {
expect(foldAt("Feature: Checkout")).toBe("| card |");
expect(foldAt("Background:")).toBe("Given a cart");
expect(foldAt("Scenario Outline: pay with <method>")).toBe("| card |");
expect(foldAt('When I pay with "<method>":')).toBe("| 10 |");
expect(foldAt('"""')).toBe('"""');
expect(foldAt("Given a cart")).toBeNull();
expect(foldAt("@smoke")).toBeNull();
});
});
-51
Переглянути файл
@@ -1,51 +0,0 @@
/**
* Gherkin (`.feature`): the legacy-mode highlighting (keywords in every Gherkin
* language, tags, tables, doc strings, `<placeholders>`) plus folding of each
* section, step argument and doc string by indentation, as Cucumber's outline does.
*/
import { LanguageSupport, StreamLanguage, foldService } from "@codemirror/language";
import { gherkin } from "@codemirror/legacy-modes/mode/gherkin";
import type { EditorState } from "@codemirror/state";
export const gherkinLanguage = StreamLanguage.define(gherkin);
const indentOf = (text: string) => /^\s*/.exec(text)![0].replace(/\t/g, " ").length;
/**
* A header line — `Feature:`, `Scenario:`, a step ending in `:` before its table, an
* opening `"""` — folds the more indented lines below it, up to the last of them.
*/
export function gherkinFold(
state: EditorState,
lineStart: number,
lineEnd: number,
): { from: number; to: number } | null {
const doc = state.doc;
const header = doc.lineAt(lineStart);
const text = header.text.trim();
if (!text || text.startsWith("#") || text.startsWith("|") || text.startsWith("@")) return null;
const docString = /^("""|```)/.exec(text);
if (docString) {
// The matching closing fence, at any indentation.
for (let n = header.number + 1; n <= doc.lines; n++) {
const line = doc.line(n);
if (line.text.trim().startsWith(docString[1]!))
return n > header.number + 1 ? { from: lineEnd, to: line.to } : null;
}
return null;
}
if (!text.endsWith(":") && !/^[^\s:]+(\s[^\s:]+)*:\s/.test(text)) return null;
const own = indentOf(header.text);
let last = header.number;
for (let n = header.number + 1; n <= doc.lines; n++) {
const line = doc.line(n);
if (!line.text.trim()) continue;
if (indentOf(line.text) <= own && !line.text.trim().startsWith("#")) break;
last = n;
}
return last > header.number ? { from: lineEnd, to: doc.line(last).to } : null;
}
export function gherkinSupport(): LanguageSupport {
return new LanguageSupport(gherkinLanguage, [foldService.of(gherkinFold)]);
}
+10 -38
Переглянути файл
@@ -1,4 +1,4 @@
import { afterEach, describe, expect, it, vi } from "vitest";
import { afterEach, describe, expect, it } from "vitest";
import { Compartment, EditorState, type Extension } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { indentUnit } from "@codemirror/language";
@@ -46,25 +46,23 @@ describe("indent guides", () => {
expect(guideVars(1, 4)).toBeNull();
expect(guideVars(3, 4)).toEqual({
images: "var(--openidea-guide), var(--openidea-guide)",
positions: "calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
positions: "calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0",
});
});
it("positions each guide the same way on lines of different depth", () => {
const v = mount(SOURCE);
expect(line(v, 1).classList.contains("cm-openidea-guides")).toBe(false);
expect(line(v, 2).style.getPropertyValue("--openidea-guide-positions")).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0",
);
expect(line(v, 2).style.getPropertyValue("--openidea-guide-positions")).toBe("calc(0.5px + 4ch) 0");
expect(line(v, 3).style.getPropertyValue("--openidea-guide-positions")).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
"calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0",
);
});
it("keeps guides through blank lines inside a block", () => {
const v = mount(SOURCE);
expect(line(v, 4).style.getPropertyValue("--openidea-guide-positions")).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
"calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0",
);
});
@@ -79,9 +77,7 @@ describe("indent guides", () => {
]);
const [implLens, fnLens] = [...v.contentDOM.querySelectorAll<HTMLElement>(".cm-openidea-lens")];
expect(v.contentDOM.classList.contains("cm-openidea-guidesOn")).toBe(true);
expect(fnLens!.style.getPropertyValue("--openidea-guide-positions")).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0",
);
expect(fnLens!.style.getPropertyValue("--openidea-guide-positions")).toBe("calc(0.5px + 4ch) 0");
expect(implLens!.style.getPropertyValue("--openidea-guide-positions")).toBe("");
});
});
@@ -140,7 +136,7 @@ describe("rainbow indent guides", () => {
expect(guideVars(1, 4, true)).toBeNull();
expect(guideVars(3, 4, true)).toEqual({
images: "var(--openidea-guide-1), var(--openidea-guide-2)",
positions: "calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
positions: "calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0",
});
const deep = guideVars(8, 2, true)!;
expect(deep.images.split(", ")).toEqual([1, 2, 3, 4, 5, 1, 2].map((n) => `var(--openidea-guide-${n})`));
@@ -160,9 +156,7 @@ describe("rainbow indent guides", () => {
expect(images(line(v, 2))).toBe("var(--openidea-guide-1)");
expect(images(line(v, 3))).toBe("var(--openidea-guide-1), var(--openidea-guide-2)");
expect(images(line(v, 4))).toBe("var(--openidea-guide-1), var(--openidea-guide-2)");
expect(positions(line(v, 4))).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
);
expect(positions(line(v, 4))).toBe("calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0");
expect(images(line(v, 6))).toBe("var(--openidea-guide-1)");
});
@@ -176,27 +170,7 @@ describe("rainbow indent guides", () => {
spaces.destroy();
const tabs = mount(body("\t"), [EditorState.tabSize.of(4)], rainbowIndentGuides, "\t");
expect(images(deepest(tabs))).toBe(expected);
expect(positions(deepest(tabs)).split(/, (?=calc)/)[1]).toBe("calc(0.5px + 8 * var(--openidea-space, 1ch)) 0");
});
it("measures a column as the font's space width, so a proportional font keeps guides in the indentation", () => {
const rect = vi.spyOn(HTMLElement.prototype, "getBoundingClientRect").mockImplementation(function (
this: HTMLElement,
) {
const sample = this.textContent ?? "";
const width = /^ +$/.test(sample) ? sample.length * 3.5 : 0;
return { width, height: 0, top: 0, left: 0, right: width, bottom: 0, x: 0, y: 0, toJSON: () => ({}) };
});
try {
const v = mount(SOURCE);
(v as unknown as { measure(): void }).measure();
expect(v.scrollDOM.style.getPropertyValue("--openidea-space")).toBe("3.5px");
v.destroy();
expect(v.scrollDOM.style.getPropertyValue("--openidea-space")).toBe("");
view = undefined;
} finally {
rect.mockRestore();
}
expect(positions(deepest(tabs)).split(", ")[1]).toBe("calc(0.5px + 8ch) 0");
});
it("does not count a partial indent unit as a level", () => {
@@ -237,9 +211,7 @@ describe("rainbow indent guides", () => {
});
const lens = () => view!.contentDOM.querySelector<HTMLElement>(".cm-openidea-lens")!;
expect(images(lens())).toBe("var(--openidea-guide-1), var(--openidea-guide-2)");
expect(positions(lens())).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
);
expect(positions(lens())).toBe("calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0");
view.dispatch({ effects: guides.reconfigure(indentGuides) });
expect(images(lens())).toBe("var(--openidea-guide), var(--openidea-guide)");
});
+3 -33
Переглянути файл
@@ -7,9 +7,7 @@
* the smaller level of their neighbours and code lens rows the level of the
* line they annotate (`guideVars`), so guides stay continuous. With rainbow
* guides each depth gets its own image, coloured from `--syn-rainbow-*`. The
* guide the caret is on takes the selected colour (`caretGuide`). A column is
* the editor font's space width (`--openidea-space`, measured), not `ch`: in a
* proportional font a space is narrower than "0", and guides would drift into the code.
* guide the caret is on takes the selected colour (`caretGuide`).
*/
import { countColumn, Facet, RangeSetBuilder, type EditorState, type Extension } from "@codemirror/state";
import { Decoration, EditorView, ViewPlugin, type DecorationSet, type ViewUpdate } from "@codemirror/view";
@@ -19,11 +17,6 @@ import { LINE_INSET } from "./lineInset";
/** How far (px) a guide sits left of its column, so a caret in that column is right of it (IDEA's indent guide shift). */
const GUIDE_SHIFT = 2;
/** One column of indentation: a space in the editor font, as measured by the guides plugin. */
const SPACE = "var(--openidea-space, 1ch)";
const SPACE_SAMPLE = 64;
/** Number of `--openidea-guide-<n>` rainbow colours; deeper guides repeat them. */
export const GUIDE_COLORS = 5;
@@ -57,7 +50,7 @@ export function guideVars(
? `var(--openidea-guide-${((level - 1) % GUIDE_COLORS) + 1})`
: "var(--openidea-guide)",
);
positions.push(`calc(${LINE_INSET - GUIDE_SHIFT}px + ${level * step} * ${SPACE}) 0`);
positions.push(`calc(${LINE_INSET - GUIDE_SHIFT}px + ${level * step}ch) 0`);
}
return { images: images.join(", "), positions: positions.join(", ") };
}
@@ -194,33 +187,10 @@ export const indentGuides: Extension = [
ViewPlugin.fromClass(
class {
decorations: DecorationSet;
private probe: HTMLElement;
constructor(readonly view: EditorView) {
// Inherits the editor font from the scroller, outside the content CodeMirror observes;
// the measured width goes on the scroller, where lines and code lens rows pick it up.
this.probe = document.createElement("span");
this.probe.setAttribute("aria-hidden", "true");
this.probe.style.cssText = "position: absolute; top: 0; left: 0; visibility: hidden; white-space: pre";
this.probe.textContent = " ".repeat(SPACE_SAMPLE);
view.scrollDOM.appendChild(this.probe);
constructor(view: EditorView) {
this.decorations = build(view);
this.measure();
}
measure() {
this.view.requestMeasure({
key: this,
read: (view) => this.probe.getBoundingClientRect().width / (view.scaleX || 1) / SPACE_SAMPLE,
write: (width, view) => {
if (width > 0) view.scrollDOM.style.setProperty("--openidea-space", `${+width.toFixed(3)}px`);
},
});
}
destroy() {
this.probe.remove();
this.view.scrollDOM.style.removeProperty("--openidea-space");
}
update(u: ViewUpdate) {
if (u.geometryChanged) this.measure();
if (
u.docChanged ||
u.selectionSet ||
-5
Переглянути файл
@@ -92,11 +92,6 @@ const OWN_MODES = [
extensions: ["rst"],
load: () => import("./restructuredtext").then((m) => new LanguageSupport(m.restructuredtextLanguage)),
}),
LanguageDescription.of({
name: "Gherkin",
extensions: ["feature"],
load: () => import("./gherkin").then((m) => m.gherkinSupport()),
}),
LanguageDescription.of({
name: "Log",
extensions: ["log"],
+1 -34
Переглянути файл
@@ -1,6 +1,5 @@
import { afterEach, describe, expect, it, vi } from "vitest";
import { EditorState, StateEffect } from "@codemirror/state";
import { showTooltip, type Tooltip } from "@codemirror/view";
import { EditorState } from "@codemirror/state";
import { indentUnit, language as languageFacet } from "@codemirror/language";
import { HEAVY_LIMIT, onEditorEvent, registerSaveParticipant, remoteChange, shownAgain } from "@/editor/api";
import { createMemoryBackend, type MemoryBackend } from "../backend";
@@ -17,15 +16,6 @@ const host: SlotHost = {
onContextMenu: () => {},
};
const testTooltip: Tooltip = {
pos: 0,
create: () => {
const dom = document.createElement("div");
dom.className = "test-tab-tooltip";
return { dom };
},
};
async function settle() {
for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
}
@@ -372,29 +362,6 @@ describe("DocumentManager + slots", () => {
manager.stop();
});
it("takes a hidden tab's tooltips off the page with its view, and back when it shows again (#3647)", async () => {
const { manager } = setup({ "/p/a.txt": "abc" });
const model = await manager.acquire("/p/a.txt");
const slot = new EditorSlot(model, "t1", host);
const other = new EditorSlot(model, "t2", host);
const tooltip = () => document.querySelector(".cm-tooltip.test-tab-tooltip");
const view = slot.mount(document.body);
// Any tooltip of the tab (a hint, hover, completion…): they live in `document.body`, outside the view.
view.dispatch({ effects: StateEffect.appendConfig.of(showTooltip.of(testTooltip)) });
expect(tooltip()).not.toBeNull();
slot.unmount();
other.mount(document.body);
expect(tooltip()).toBeNull();
other.unmount();
expect(slot.mount(document.body)).toBe(view);
expect(tooltip()).not.toBeNull();
// Disposing the tab leaves nothing of it in the page.
slot.dispose();
other.dispose();
expect(tooltip()).toBeNull();
manager.stop();
});
it("destroys the least recently hidden views beyond the kept ones, and kept views on dispose", async () => {
const { manager } = setup({ "/p/a.txt": "abc" });
const model = await manager.acquire("/p/a.txt");
+1 -11
Переглянути файл
@@ -20,7 +20,7 @@ import {
type TransactionSpec,
} from "@codemirror/state";
import { historyField } from "@codemirror/commands";
import { EditorView, ViewPlugin, keymap, tooltips, type ViewUpdate } from "@codemirror/view";
import { EditorView, ViewPlugin, keymap, type ViewUpdate } from "@codemirror/view";
import {
_addEditor,
_removeEditor,
@@ -69,11 +69,6 @@ export class EditorSlot {
view: EditorView | null = null;
/** The view kept, detached from the document, while the tab is hidden. */
private kept: EditorView | null = null;
/**
* The tab's tooltips (hints, hover, completion…). They live outside the view, in `document.body`,
* so they leave the page with the view when the tab is hidden instead of floating over the next tab.
*/
private readonly tooltipLayer = typeof document === "undefined" ? null : document.createElement("div");
/** The view's scroll offset, tracked so hiding it needn't read layout. */
private scrollPos = { top: 0, left: 0 };
handle: TextEditorHandle | null = null;
@@ -171,8 +166,6 @@ export class EditorSlot {
}
}),
Prec.highest(keymap.of([{ key: "Escape", run: () => this.host.onEscape?.(this) ?? false }])),
// Ahead of the shared `document.body` parent (the tooltip space still comes from it).
this.tooltipLayer ? Prec.highest(tooltips({ parent: this.tooltipLayer })) : [],
EditorView.domEventObservers({
scroll: (_e, view) => {
if (view === this.view) this.scrollPos = { top: view.scrollDOM.scrollTop, left: view.scrollDOM.scrollLeft };
@@ -207,7 +200,6 @@ export class EditorSlot {
mount(parent: HTMLElement): EditorView {
if (this.view) return this.view;
if (this.tooltipLayer && !this.tooltipLayer.isConnected) document.body.appendChild(this.tooltipLayer);
const kept = this.kept;
let view: EditorView;
if (kept) {
@@ -251,7 +243,6 @@ export class EditorSlot {
this.kept = view;
if (!keep) return this.release();
view.dom.remove();
this.tooltipLayer?.remove();
keptSlots.push(this);
if (keptSlots.length > KEPT_VIEWS) keptSlots.shift()!.release();
}
@@ -267,7 +258,6 @@ export class EditorSlot {
this.scroll = scrollSnapshotAt(view, this.scrollPos);
this.stored = view.state;
view.destroy();
this.tooltipLayer?.remove();
}
dispose() {
+4 -4
Переглянути файл
@@ -74,8 +74,9 @@ export function showHint(
clearTimeout(timers.get(view));
timers.set(
view,
// Also while the view is hidden: it would show the hint again when its tab is shown.
setTimeout(() => hideHint(view), opts.timeout ?? 4000),
setTimeout(() => {
if (view.dom.isConnected && view.state.field(hintField, false)) view.dispatch({ effects: setHint.of(null) });
}, opts.timeout ?? 4000),
);
}
@@ -103,10 +104,9 @@ export function showPendingHint(view: EditorView, content: string): () => void {
}, PENDING_HINT_DELAY_MS);
return () => {
clearTimeout(timer);
// Also when the request ended by opening another tab, which hid this view.
if (shown && view.state.field(hintField, false) === shown) {
clearTimeout(timers.get(view));
hideHint(view);
if (view.dom.isConnected) hideHint(view);
}
};
}
+3 -5
Переглянути файл
@@ -89,13 +89,11 @@ export function cellLspExtensions(ctx: EditorDocContext): Extension[] {
}
/**
* A diff pane showing a file's open document: hover / quick docs, ⌘/Ctrl-click
* navigation and semantic highlighting, so colours match the editor while
* reviewing. Editing features stay with text editors; panes without a document
* (revisions) get nothing from the semantic extension (`docOf` is null).
* A diff pane showing a file's open document: hover / quick docs and ⌘/Ctrl-click navigation,
* so references can be followed while reviewing. Editing features stay with text editors.
*/
export function diffLspExtensions(ctx: EditorDocContext): Extension[] {
return [lspDoc.of(ctx), lspTheme, hintExtension(), hoverExtension(), navigationExtension(), semanticExtension()];
return [lspDoc.of(ctx), lspTheme, hintExtension(), hoverExtension(), navigationExtension()];
}
export function activate(): () => void {
+5 -16
Переглянути файл
@@ -159,8 +159,7 @@ function shownKind(kind: InlayHint["kind"]): boolean {
const inlayPlugin = ViewPlugin.fromClass(
class {
private generation = 0;
private schedule = debounce(() => void this.run(), 400);
private refresh = debounce(() => void this.run(), 400);
private unsubscribe: () => void;
private offReady: () => void;
private offSettled: () => void;
@@ -186,10 +185,6 @@ const inlayPlugin = ViewPlugin.fromClass(
update(u: ViewUpdate) {
if (u.docChanged || u.viewportChanged || (this.skipped && shownAgain(u))) this.refresh();
}
private refresh() {
this.generation++;
this.schedule();
}
async run() {
const view = this.view;
this.skipped = !view.dom.isConnected;
@@ -209,17 +204,12 @@ const inlayPlugin = ViewPlugin.fromClass(
return;
}
const state = view.state;
const generation = this.generation;
const wanted = () => generation === this.generation && view.state.doc === state.doc;
const { from, to } = view.viewport;
const first = state.doc.lineAt(from).from;
const last = state.doc.lineAt(to).to;
try {
const hints = await lspRequest(
() => commands.lspInlayHints(doc.doc, offsetsToRange(state.doc, first, last)),
wanted,
);
if (!wanted()) return;
const hints = await lspRequest(() => commands.lspInlayHints(doc.doc, offsetsToRange(state.doc, first, last)));
if (view.state.doc !== state.doc) return this.refresh();
const fresh = hints.filter((h) => shownKind(h.kind));
// A busy server (indexing, loading a build) can answer with nothing: keep the
// hints shown until it settles, instead of blinking them away and reflowing
@@ -230,12 +220,11 @@ const inlayPlugin = ViewPlugin.fromClass(
effects: setInlays.of(inlayDecorations(view, fresh)),
});
} catch (e) {
if (wanted() && isUnavailable(e)) inlayBackoff.mark(doc.doc);
if (isUnavailable(e)) inlayBackoff.mark(doc.doc);
}
}
destroy() {
this.generation++;
this.schedule.cancel();
this.refresh.cancel();
this.unsubscribe();
this.offReady();
this.offSettled();
-184
Переглянути файл
@@ -1,184 +0,0 @@
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { _addEditor, _removeEditor, documentSynced, viewShown } from "@/editor/api";
import type { InlayHint } from "@/bindings";
const ipc = vi.hoisted(() => ({ lspInlayHints: vi.fn() }));
vi.mock("@/platform/ipc", async (orig) => {
const real = await orig<typeof import("@/platform/ipc")>();
return { ...real, isTauri: () => true, commands: { ...real.commands, ...ipc } };
});
const { inlayExtension } = await import("./inlay");
const { lspDoc } = await import("./lsp");
const { useProject } = await import("@/platform/project");
const { emitLocalIdeEvent } = await import("@/platform/ipc");
const views: EditorView[] = [];
const ok = (label: string) => ({
status: "ok" as const,
data: [
{
position: { line: 0, col: 5 },
label,
kind: "type",
parts: [],
paddingLeft: false,
paddingRight: false,
tooltip: null,
},
] as InlayHint[],
});
function deferred<T>() {
let resolve!: (value: T) => void;
const promise = new Promise<T>((r) => (resolve = r));
return { promise, resolve };
}
const ctx = { doc: 71, path: "/p/a.rs", language: "rust", uiMode: "Rust", readOnly: false };
function editor(sync?: () => Promise<void>) {
const view = new EditorView({
state: EditorState.create({
doc: "let x = 1;",
extensions: [lspDoc.of(ctx), ...(sync ? [documentSynced.of(sync)] : []), inlayExtension()],
}),
parent: document.body,
});
views.push(view);
return view;
}
const labels = (view: EditorView) => [...view.dom.querySelectorAll(".cm-lsp-inlay")].map((e) => e.textContent);
beforeEach(() => {
vi.useFakeTimers();
ipc.lspInlayHints.mockReset().mockResolvedValue(ok("current"));
useProject.setState({ settings: { editor: { inlayHints: true } } as never });
});
afterEach(() => {
views.splice(0).forEach((v) => v.destroy());
useProject.setState({ settings: null });
vi.useRealTimers();
});
describe("inlay request lifetime", () => {
it("does not restore hints after they were disabled", async () => {
const old = deferred<ReturnType<typeof ok>>();
ipc.lspInlayHints.mockReturnValueOnce(old.promise);
const view = editor();
await vi.advanceTimersByTimeAsync(400);
useProject.setState({ settings: { editor: { inlayHints: false } } as never });
await vi.advanceTimersByTimeAsync(400);
old.resolve(ok("stale"));
await vi.advanceTimersByTimeAsync(1);
expect(labels(view)).toEqual([]);
});
it("does not overwrite a newer server refresh with an older response", async () => {
const old = deferred<ReturnType<typeof ok>>();
ipc.lspInlayHints.mockReturnValueOnce(old.promise);
const view = editor();
await vi.advanceTimersByTimeAsync(400);
emitLocalIdeEvent({ type: "lspRefresh", kind: "inlayHints", server: 1 });
await vi.advanceTimersByTimeAsync(400);
expect(labels(view)).toEqual(["current"]);
old.resolve(ok("stale"));
await vi.advanceTimersByTimeAsync(1);
expect(labels(view)).toEqual(["current"]);
});
});
describe("obsolete inlay work", () => {
it("invalidates immediately, before the next debounced request starts", async () => {
const old = deferred<ReturnType<typeof ok>>();
ipc.lspInlayHints.mockReturnValueOnce(old.promise);
const view = editor();
await vi.advanceTimersByTimeAsync(400);
emitLocalIdeEvent({ type: "lspRefresh", kind: "inlayHints", server: 1 });
old.resolve(ok("stale"));
await vi.advanceTimersByTimeAsync(1);
expect(labels(view)).toEqual([]);
await vi.advanceTimersByTimeAsync(399);
expect(labels(view)).toEqual(["current"]);
});
it("does not dispatch a response into a destroyed editor", async () => {
const old = deferred<ReturnType<typeof ok>>();
ipc.lspInlayHints.mockReturnValueOnce(old.promise);
const view = editor();
await vi.advanceTimersByTimeAsync(400);
view.destroy();
views.splice(views.indexOf(view), 1);
const dispatch = vi.spyOn(view, "dispatch");
old.resolve(ok("stale"));
await vi.advanceTimersByTimeAsync(400);
expect(dispatch).not.toHaveBeenCalled();
});
it("does not send obsolete requests after waiting for document synchronization", async () => {
const synced = deferred<void>();
const view = editor(() => synced.promise);
const handle = { view, ctx };
_addEditor(handle);
try {
await vi.advanceTimersByTimeAsync(400);
expect(ipc.lspInlayHints).not.toHaveBeenCalled();
view.destroy();
views.splice(views.indexOf(view), 1);
synced.resolve();
await vi.advanceTimersByTimeAsync(400);
expect(ipc.lspInlayHints).not.toHaveBeenCalled();
} finally {
_removeEditor(handle);
}
});
});
describe("retained editors", () => {
it("keeps an in-flight response when the editor is detached then shown again", async () => {
const pending = deferred<ReturnType<typeof ok>>();
ipc.lspInlayHints.mockReturnValueOnce(pending.promise);
const view = editor();
await vi.advanceTimersByTimeAsync(400);
view.dom.remove();
pending.resolve(ok("retained"));
await vi.advanceTimersByTimeAsync(1);
document.body.append(view.dom);
view.dispatch({ effects: viewShown.of(null) });
await vi.advanceTimersByTimeAsync(400);
expect(labels(view)).toEqual(["retained"]);
});
it("keeps work waiting for document synchronization when detached then shown again", async () => {
const synced = deferred<void>();
const view = editor(() => synced.promise);
const handle = { view, ctx };
_addEditor(handle);
try {
await vi.advanceTimersByTimeAsync(400);
expect(ipc.lspInlayHints).not.toHaveBeenCalled();
view.dom.remove();
synced.resolve();
await vi.advanceTimersByTimeAsync(1);
document.body.append(view.dom);
view.dispatch({ effects: viewShown.of(null) });
await vi.advanceTimersByTimeAsync(400);
expect(labels(view)).toEqual(["current"]);
} finally {
_removeEditor(handle);
}
});
});
describe("settled refresh request lifetime", () => {
it.each([true, false])("rejects old busy answers after a settled refresh (empty=%s)", async (empty) => {
const view = editor();
await vi.advanceTimersByTimeAsync(400);
expect(labels(view)).toEqual(["current"]);
const old = deferred<ReturnType<typeof ok>>();
ipc.lspInlayHints.mockReturnValueOnce(old.promise);
emitLocalIdeEvent({ type: "languageServer", server: 91, name: "rust-analyzer", status: "busy", message: null });
emitLocalIdeEvent({ type: "lspRefresh", kind: "inlayHints", server: 91 });
await vi.advanceTimersByTimeAsync(1600);
const settled = empty ? { status: "ok" as const, data: [] } : ok("settled");
ipc.lspInlayHints.mockResolvedValue(settled);
emitLocalIdeEvent({ type: "languageServer", server: 91, name: "rust-analyzer", status: "ready", message: null });
// Settling invalidates immediately, not only after the debounce delay.
old.resolve(ok("stale busy"));
await vi.advanceTimersByTimeAsync(1);
expect(labels(view)).toEqual(["current"]);
await vi.advanceTimersByTimeAsync(399);
expect(labels(view)).toEqual(empty ? [] : ["settled"]);
});
});
-21
Переглянути файл
@@ -70,27 +70,6 @@ describe("slow navigation feedback", () => {
expect(document.querySelector(".cm-lsp-hint")).toBeNull();
});
it("clears the progress hint when the target opens in another tab and hides this view (#3647)", async () => {
let resolve!: (result: Awaited<ReturnType<typeof commands.lspGotoImplementation>>) => void;
lspGotoImplementation.mockImplementationOnce(() => new Promise((r) => (resolve = r)));
// Opening the target's tab detaches this tab's view, as `EditorSlot.unmount` does.
openFile.mockImplementationOnce(async () => view.dom.remove());
const pending = gotoTargets(view, "implementation");
await vi.advanceTimersByTimeAsync(250);
expect(document.querySelector(".cm-lsp-hint")?.textContent).toBe("Finding navigation target…");
resolve({
status: "ok",
data: [{ path: "/p/Impl.java", range: { start: { line: 1, col: 0 }, end: { line: 1, col: 4 } }, uri: null }],
});
await pending;
expect(openFile).toHaveBeenCalled();
expect(view.dom.isConnected).toBe(false);
expect(document.querySelector(".cm-lsp-hint")).toBeNull();
// Shown again, the tab has no stale progress hint.
document.body.appendChild(view.dom);
expect(document.querySelector(".cm-lsp-hint")).toBeNull();
});
it("shows progress while the chooser's rows load after a quick answer, until the chooser opens", async () => {
let finish!: (files: Map<string, string[]>) => void;
vi.spyOn(files, "readManyFileLines").mockImplementationOnce(() => new Promise((r) => (finish = r)));
+2 -41
Переглянути файл
@@ -66,7 +66,7 @@ import {
} from "./composerModel";
import { referenceExtensions, setReferences } from "./composerEditor";
import { referenceHover } from "./ReferenceChip";
import { composerDraft, provideIdeContext, setIdeContext, updateComposer, useAgents } from "./store";
import { composerDraft, updateComposer, useAgents } from "./store";
import { ImagePreview, imageSrc } from "./ImagePreview";
import { useAgentSettings } from "./agentSettings";
import styles from "./Composer.module.css";
@@ -933,27 +933,6 @@ export function Composer(props: ComposerProps) {
return { path: activePath, rel };
}, [activePath, projectRoot, root, text]);
const ideContext = useAgents((s) => s.ideContext);
useEffect(
() =>
provideIdeContext(id, () => {
const active = useEditorRegistry.getState().active;
const path = active?.ctx.path;
if (!active || !path || isVirtualUri(path)) return null;
const rel = relativeTo([projectRoot, root], path);
if (!rel || rel === ".") return null;
const { doc, selection } = active.view.state;
const { from, to } = selection.main;
if (from === to) return { path, rel };
const first = doc.lineAt(from).number;
const end = doc.lineAt(to);
// A selection ending at the start of a line does not take that line.
const last = end.from === to && end.number > first ? end.number - 1 : end.number;
return { path, rel, lines: { from: first, to: last } };
}),
[id, projectRoot, root],
);
const showContext = images.length > 0 || attached.length > 0 || !!suggested;
return (
@@ -1077,14 +1056,7 @@ export function Composer(props: ComposerProps) {
)}
{showContext && (
<div className={styles.context} onMouseDown={(e) => e.stopPropagation()}>
{suggested && ideContext && (
<span className={styles.attachment} title={tx`${suggested.rel} is added to your request`}>
<Icon name={fileIconName(basename(suggested.rel), suggested.rel)} size={14} />
<span className={styles.attachmentName}>{basename(suggested.rel)}</span>
<span className={styles.suggestionHint}>{tx("Current File")}</span>
</span>
)}
{suggested && !ideContext && (
{suggested && (
<button
type="button"
className={styles.suggestion}
@@ -1155,17 +1127,6 @@ export function Composer(props: ComposerProps) {
replace(from, to, before && !/\s/.test(before) ? " @" : "@");
}}
/>
<IconButton
icon="file-code"
title={
ideContext
? "IDE Context Enabled: the current file and selection are added to your request"
: "IDE Context Disabled: the current file and selection are not added to your request"
}
pressed={ideContext}
className={styles.composerButton}
onClick={() => setIdeContext(!ideContext)}
/>
<IconButton
icon="image"
title="Attach Image…"
+8 -31
Переглянути файл
@@ -404,13 +404,6 @@
.agentName {
display: none;
}
.processBody,
.turnBody {
padding-left: var(--space-2);
}
.processBody > .thoughtEntry ~ .toolEntry {
padding-left: var(--space-3);
}
}
.messageActions {
display: inline-flex;
@@ -778,10 +771,6 @@
margin-bottom: 0;
}
.thoughtEntry,
.toolEntry {
min-width: 0;
}
.thought summary,
.toolDetails > summary {
cursor: pointer;
@@ -794,18 +783,15 @@
.thought summary {
display: flex;
align-items: center;
gap: var(--space-1-5);
gap: var(--space-1);
min-width: 0;
min-height: var(--h-row);
padding: 0 calc(var(--space-2) / 2);
border-radius: var(--radius-row);
color: var(--fg-muted);
font-size: var(--agent-fs-small, var(--fs-small));
-webkit-user-select: none;
user-select: none;
}
.thought summary:hover {
background: var(--bg-hover);
color: var(--fg);
}
.thoughtChevron {
@@ -821,9 +807,7 @@
transform: rotate(90deg);
}
.thoughtBody {
margin: var(--space-1-5) 0 var(--space-1) 10px;
padding-left: var(--space-3);
border-left: 1px solid var(--border);
margin-top: var(--space-2);
color: var(--fg-secondary);
}
.thoughtText {
@@ -837,7 +821,7 @@
.tool {
display: flex;
align-items: center;
gap: var(--space-1-5);
gap: var(--space-2);
min-width: 0;
box-sizing: border-box;
min-height: var(--h-row);
@@ -864,10 +848,6 @@
.toolChevron {
flex: none;
}
.toolChevronSpacer {
width: 12px;
flex: none;
}
.toolDetails[open] > summary .toolChevron {
transform: rotate(90deg);
}
@@ -947,15 +927,12 @@
gap: var(--space-0-5);
max-height: calc(var(--h-row) * 16);
overflow-y: auto;
margin: 2px 0 0 10px;
padding-left: var(--space-3);
margin-top: 2px;
padding-left: 10px;
border-left: 1px solid var(--border);
}
.processBody > .thoughtEntry ~ .toolEntry {
padding-left: var(--space-4);
}
.output {
margin: 4px 0 4px 22px;
margin: 4px 0 0;
max-height: 240px;
overflow: auto;
padding: 8px 10px;
@@ -1851,8 +1828,8 @@
display: flex;
flex-direction: column;
gap: var(--space-2);
margin: 2px 0 0 10px;
padding-left: var(--space-3);
margin-top: 2px;
padding-left: 10px;
border-left: 1px solid var(--border);
}
+4 -7
Переглянути файл
@@ -1426,7 +1426,7 @@ function ThoughtEntry({
if (working && open) onDiagramDrawn();
}, [shown, working, open, onDiagramDrawn]);
return (
<div className={clsx(styles.process, styles.thoughtEntry)}>
<div className={styles.process}>
<Fold
className={clsx(styles.thought, thinking === "auto" && working && styles.thoughtLive)}
open={open}
@@ -2072,15 +2072,12 @@ const ToolEntry = memo(function ToolEntry({
);
if (!entry.output)
return (
<div className={clsx(styles.process, styles.toolEntry)}>
<div className={styles.tool}>
<span className={styles.toolChevronSpacer} aria-hidden="true" />
{head}
</div>
<div className={styles.process}>
<div className={styles.tool}>{head}</div>
</div>
);
return (
<div className={clsx(styles.process, styles.toolEntry)}>
<div className={styles.process}>
<Fold
className={styles.toolDetails}
open={liveTool(entry) || expandToolOutput}
+1 -45
Переглянути файл
@@ -14,7 +14,6 @@ const pathCompletions = vi.fn();
const fsProbe = vi.fn();
const fsEntryKind = vi.fn();
const findSymbols = vi.fn();
const agentPrompt = vi.fn((..._args: unknown[]) => Promise.resolve({ status: "ok", data: null }));
vi.mock("@/platform/ipc", async (importOriginal) => {
const real = await importOriginal<typeof import("@/platform/ipc")>();
@@ -29,7 +28,6 @@ vi.mock("@/platform/ipc", async (importOriginal) => {
fsProbe: (path: string) => fsProbe(path),
fsEntryKind: (path: string) => fsEntryKind(path),
findSymbols: (query: string, filter: string, limit: number) => findSymbols(query, filter, limit),
agentPrompt: (...args: unknown[]) => agentPrompt(...args),
},
};
});
@@ -37,7 +35,7 @@ vi.mock("@/platform/ipc", async (importOriginal) => {
import { Composer } from "./Composer";
import { registerAgentContextSource } from "@/workbench/contributions";
import { useEditorRegistry, type TextEditorHandle } from "@/editor/api";
import { composerDraft, sendMessage, setIdeContext, updateComposer, useAgents } from "./store";
import { composerDraft, updateComposer } from "./store";
import { emptyDraft, toPrompt } from "./composerModel";
const ID = "folders-test";
@@ -320,7 +318,6 @@ describe("Composer editing", () => {
describe("Composer current file", () => {
it("offers the focused editor's file until the draft references it", () => {
const view = {} as TextEditorHandle["view"];
act(() => setIdeContext(false));
act(() =>
useEditorRegistry.setState({ active: { view, ctx: { path: "/p/src/main.ts" } as TextEditorHandle["ctx"] } }),
);
@@ -339,47 +336,6 @@ describe("Composer current file", () => {
});
});
describe("Composer IDE context", () => {
it("sends the focused editor's file, or its selected lines, while IDE context is on", async () => {
const view = new EditorView({ doc: "a\nb\nc\nd\n" });
act(() => setIdeContext(true));
act(() =>
useEditorRegistry.setState({ active: { view, ctx: { path: "/p/src/main.ts" } as TextEditorHandle["ctx"] } }),
);
try {
renderComposer();
const toggle = screen.getByRole("button", { name: /IDE Context Enabled/ });
expect(toggle).toHaveAttribute("aria-pressed", "true");
expect(screen.queryByRole("button", { name: /main\.ts/ })).toBeNull();
expect(screen.getByTitle("src/main.ts is added to your request")).toHaveTextContent("Current File");
const send = async (text: string) => {
updateComposer(ID, { text });
await sendMessage(ID, false);
return agentPrompt.mock.lastCall?.[1];
};
expect(await send("explain")).toEqual({ text: "explain", files: ["/p/src/main.ts"], images: [] });
// Lines 2–3: the selection ends at the start of line 4.
view.dispatch({ selection: { anchor: 2, head: 6 } });
expect(await send("explain")).toEqual({
text: "explain\n\n@src/main.ts:2-3",
files: ["/p/src/main.ts"],
images: [],
});
// A draft that already references the file is sent as written.
expect(await send("see @src/main.ts:1")).toEqual({ text: "see @src/main.ts:1", files: [], images: [] });
fireEvent.click(toggle);
expect(useAgents.getState().ideContext).toBe(false);
expect(screen.getByRole("button", { name: /IDE Context Disabled/ })).toHaveAttribute("aria-pressed", "false");
expect(await send("explain")).toEqual({ text: "explain", files: [], images: [] });
} finally {
act(() => useEditorRegistry.setState({ active: null }));
view.destroy();
}
});
});
describe("Composer pasted code and terminal output", () => {
const paste = (box: HTMLElement, text: string) =>
act(() => {
-30
Переглянути файл
@@ -317,36 +317,6 @@ export function mentionOf(rel: string, lines?: { from: number; to: number }): st
export const isMentioned = (text: string, rel: string) =>
new RegExp(`@${escapeRe(rel)}(?![\\w./-])|@${escapeRe(rel)}:`).test(text);
/** The file in the focused editor and the lines selected in it, for IDE context. */
export interface IdeContext {
path: string;
rel: string;
/** 1-based lines of a non-empty selection. */
lines?: { from: number; to: number };
}
/**
* `draft` with the editor's current file added (as an attachment), or its selection as a
* line-range mention after the text; unchanged when the draft already references the file.
*/
export function withIdeContext(draft: ComposerDraft, context: IdeContext | null): ComposerDraft {
if (
!context ||
isMentioned(draft.text, context.rel) ||
draft.files.some((f) => f.path === context.path && f.attached)
)
return draft;
if (!context.lines)
return { ...draft, files: [...draft.files, { path: context.path, rel: context.rel, attached: true }] };
const mention = mentionOf(context.rel, context.lines);
const text = draft.text.trim();
return {
...draft,
text: text ? `${text}\n\n${mention}` : mention,
files: [...draft.files, { path: context.path, rel: context.rel }],
};
}
/** The prompt to send: attached files, files still mentioned in the text (each once), and the images. */
export function toPrompt(draft: ComposerDraft): AgentPrompt {
const seen = new Set<string>();
+2 -31
Переглянути файл
@@ -14,7 +14,6 @@ import type {
AgentImage,
AgentLimit,
AgentModelCatalog,
AgentPrompt,
AgentProvider,
AgentTask,
ExternalSession,
@@ -36,10 +35,8 @@ import {
isMentioned,
isPerModelOption,
toPrompt,
withIdeContext,
type ComposerDraft,
type FileRef,
type IdeContext,
} from "./composerModel";
import { withQuote } from "./conversation";
import {
@@ -130,8 +127,6 @@ interface AgentsState {
/** Side conversations by task id: kept out of the task list, discarded when their view closes. */
ephemeral: ReadonlySet<string>;
pinnedModels: string[];
/** Whether messages carry the editor's current file and selection. */
ideContext: boolean;
}
const DRAFT_KEY = "openidea.agents.draft.v2";
@@ -139,7 +134,6 @@ const HISTORY_KEY = "openidea.agents.history.v1";
const HISTORY_SIZE = 50;
const SESSION_LOCATION_KEY = "openidea.agents.sessionLocation.v1";
const PINNED_MODELS_KEY = "openidea.agents.pinnedModels.v1";
const IDE_CONTEXT_KEY = "openidea.agents.ideContext.v1";
function load<T>(key: string, fallback: T): T {
try {
@@ -204,7 +198,6 @@ export const useAgents = create<AgentsState>(() => ({
homeOpen: false,
ephemeral: new Set<string>(),
pinnedModels: load<string[]>(PINNED_MODELS_KEY, []),
ideContext: load<boolean>(IDE_CONTEXT_KEY, true),
scrollPositions: new Map(),
}));
@@ -979,7 +972,7 @@ export async function startTask(
const task = await call(
commands.agentCreate({
projectRoot,
prompt: promptOf(HOME, composer),
prompt: toPrompt(composer),
provider: draft.provider,
config,
isolation,
@@ -1093,28 +1086,6 @@ export async function importExternalSessions(
void showError(title, failures.join("\n"));
}
export function setIdeContext(on: boolean) {
useAgents.setState({ ideContext: on });
save(IDE_CONTEXT_KEY, on);
}
/** The IDE context of each mounted composer, by draft key. */
const ideContexts = new Map<string, () => IdeContext | null>();
/** Registers what composer `key` sends as IDE context; returns the unregister. */
export function provideIdeContext(key: string, context: () => IdeContext | null): () => void {
ideContexts.set(key, context);
return () => {
if (ideContexts.get(key) === context) ideContexts.delete(key);
};
}
/** The prompt of composer `key`, with the IDE context when it is on. */
function promptOf(key: string, composer: ComposerDraft): AgentPrompt {
const context = useAgents.getState().ideContext ? (ideContexts.get(key)?.() ?? null) : null;
return toPrompt(withIdeContext(composer, context));
}
function remember(text: string) {
if (!text) return;
const history = [text, ...useAgents.getState().history.filter((h) => h !== text)].slice(0, HISTORY_SIZE);
@@ -1127,7 +1098,7 @@ export async function sendMessage(task: string, now: boolean): Promise<void> {
const composer = composerDraft(task);
if (!canSend(composer)) return;
const started = generation;
await call(commands.agentPrompt(task, promptOf(task, composer), now));
await call(commands.agentPrompt(task, toPrompt(composer), now));
clearSubmittedComposer(task, composer, started);
}
+18 -207
Переглянути файл
@@ -11,13 +11,7 @@ const component = (name: string, options: Record<string, string>) =>
.map(([k, v]) => `<option name="${k}" value="${v}" />`)
.join("")}</component></application>`;
const settings = {
editor: { fontFamily: "JetBrains Mono", fontSize: 13, customSchemes: {}, colorOverrides: {} },
customKeymaps: {},
};
/** JetBrains Maple Mono's metrics (ascent 1.02em, descent 0.3em), for any family. */
const fontHeight = (_family: string, size: number) => Math.ceil(size * 1.02) + Math.ceil(size * 0.3);
const editor = { fontSize: 13, customSchemes: {}, colorOverrides: {} };
/** A WebStorm export, trimmed to what the import reads. */
const webstorm = {
@@ -57,8 +51,8 @@ const webstorm = {
};
describe("planJetBrainsImport", () => {
it("maps a WebStorm export to the settings it has, and lists what is left out", async () => {
const plan = await planJetBrainsImport(webstorm, settings, fontHeight);
it("maps a WebStorm export to the settings it has, and lists what is left out", () => {
const plan = planJetBrainsImport(webstorm, editor);
const writes = Object.fromEntries(plan.writes);
const schemes = writes["editor.customSchemes"] as Record<string, { name: string; parent: string }>;
const [id, scheme] = Object.entries(schemes)[0]!;
@@ -68,15 +62,12 @@ describe("planJetBrainsImport", () => {
"editor.colorScheme": id,
"editor.fontFamily": "JetBrains Maple Mono",
"editor.fontSize": 17,
// (18 + 6) × the default spacing 1.2, rounded up, as WebStorm draws it.
"editor.lineHeight": 29,
"editor.ligatures": true,
"files.trimTrailingWhitespace": true,
"editor.general.stripTrailingScope": "all",
"files.ensureFinalNewline": true,
"editor.stickyScroll": false,
"editor.softWrap": false,
"console.softWrap": true,
"general.confirmExit": false,
});
expect(plan.rows).toContainEqual({
@@ -88,12 +79,12 @@ describe("planJetBrainsImport", () => {
label: "Remove trailing spaces on:",
value: "All lines",
});
expect(plan.skipped).toEqual(["Code Style options other than Tabs and Indents", "Inspections", "Plugins"]);
expect(plan.skipped).toEqual(["Keymap", "Code Style", "Inspections", "Plugins"]);
expect(plan.invalid).toEqual([]);
});
it("writes only the keys present, and derives the line height from IDEA's spacing", async () => {
const plan = await planJetBrainsImport(
it("writes only the keys present, and derives the line height from IDEA's spacing", () => {
const plan = planJetBrainsImport(
{
entries: [],
files: {
@@ -106,213 +97,33 @@ describe("planJetBrainsImport", () => {
}),
},
},
settings,
fontHeight,
editor,
);
expect(plan.writes).toEqual([
// (14 + 4) × 1.5
["editor.lineHeight", 27],
["editor.lineHeight", 20],
["files.trimTrailingWhitespace", false],
["editor.softWrap", true],
["console.softWrap", true],
]);
expect(plan.skipped).toEqual([]);
});
it("re-importing replaces the earlier copy of a scheme and drops its edits", async () => {
const first = Object.fromEntries((await planJetBrainsImport(webstorm, settings, fontHeight)).writes);
const customs = first["editor.customSchemes"] as typeof settings.editor.customSchemes;
it("re-importing replaces the earlier copy of a scheme and drops its edits", () => {
const first = Object.fromEntries(planJetBrainsImport(webstorm, editor).writes);
const customs = first["editor.customSchemes"] as typeof editor.customSchemes;
const [id] = Object.keys(customs);
const again = await planJetBrainsImport(
webstorm,
{
...settings,
editor: {
...settings.editor,
customSchemes: customs,
colorOverrides: { [id!]: { keyword: { bold: true } }, other: {} },
},
},
fontHeight,
);
const again = planJetBrainsImport(webstorm, {
...editor,
customSchemes: customs,
colorOverrides: { [id!]: { keyword: { bold: true } }, other: {} },
});
const writes = Object.fromEntries(again.writes);
expect(Object.keys(writes["editor.customSchemes"] as object)).toEqual([id]);
expect(writes["editor.colorOverrides"]).toEqual({ other: {} });
expect(writes["editor.colorScheme"]).toBe(id);
});
it("falls back to the font size when the font cannot be measured", async () => {
const plan = await planJetBrainsImport(
{ entries: [], files: { "options/editor-font.xml": component("DefaultFont", { FONT_SIZE: "20" }) } },
settings,
() => undefined,
);
expect(plan.writes).toEqual([
["editor.fontSize", 20],
["editor.lineHeight", 29],
]);
});
it("imports the keymaps and makes the active one current", async () => {
const keymap =
'<keymap version="1" name="macOS copy" parent="Mac OS X 10.5+">' +
'<action id="NextTab"><keyboard-shortcut first-keystroke="ctrl right" /></action>' +
'<action id="GotoSuperMethod" /><action id="RunAnything" /></keymap>';
const active =
'<application><component name="KeymapManager"><active_keymap name="macOS copy" /></component></application>';
const bundle = {
entries: ["keymaps/macOS copy.xml", "keymaps/broken.xml"],
files: {
"keymaps/macOS copy.xml": keymap,
"keymaps/broken.xml": "<nope",
// The active keymap is stored per operating system; the host picks its own.
"options/mac/keymap.xml": active,
"options/windows/keymap.xml": active,
"options/linux/keymap.xml": active,
},
};
const plan = await planJetBrainsImport(bundle, settings);
const expected = {
name: "macOS copy",
parent: "intellij-macos",
overrides: { "editor.nextTab": ["Ctrl+Right"], "navigate.superMethod": [] },
};
expect(plan.writes).toEqual([
["customKeymaps", { "custom.macos-copy": expected }],
["keymap", "custom.macos-copy"],
]);
expect(plan.rows).toEqual([
{ label: "Keymap", value: "macOS copy" },
{ label: "Current keymap", value: "macOS copy" },
]);
expect(plan.unknownActions).toEqual(["RunAnything"]);
expect(plan.invalid).toEqual(["broken.xml"]);
// Importing again replaces the earlier copy and keeps the user's other keymaps.
const mine = { name: "Mine", parent: "vscode-macos", overrides: {} };
const again = await planJetBrainsImport(bundle, {
...settings,
customKeymaps: { "custom.macos-copy": { ...expected, overrides: {} }, "custom.mine": mine },
});
expect(again.writes[0]).toEqual(["customKeymaps", { "custom.macos-copy": expected, "custom.mine": mine }]);
});
it("imports the terminal font", async () => {
const plan = await planJetBrainsImport(
{
entries: [],
files: {
"options/terminal-font.xml": component("TerminalFontOptions", {
VERSION: "1",
FONT_SIZE: "17",
FONT_SIZE_2D: "17.0",
FONT_FAMILY: "MesloLGS NF",
LINE_SPACING: "1.1",
}),
},
},
settings,
);
expect(plan.writes).toEqual([
["terminal.useEditorFont", false],
["terminal.fontFamily", "MesloLGS NF"],
["terminal.fontSize", 17],
["terminal.lineHeight", 1.1],
]);
});
it("imports tabs and indents of the current code style scheme onto the languages' own styles", async () => {
const scheme = (name: string, body: string) => `<code_scheme name="${name}" version="173">${body}</code_scheme>`;
const plan = await planJetBrainsImport(
{
entries: ["codestyles/Default.xml", "codestyles/Team.xml"],
files: {
"options/code.style.schemes.xml": component("CodeStyleSchemeSettings", { CURRENT_SCHEME_NAME: "Team" }),
"codestyles/Default.xml": scheme(
"Default",
'<codeStyleSettings language="Python"><indentOptions><option name="INDENT_SIZE" value="8" /></indentOptions></codeStyleSettings>',
),
"codestyles/Team.xml": scheme(
"Team",
'<option name="RIGHT_MARGIN" value="100" />' +
'<option name="OTHER_INDENT_OPTIONS"><value><option name="TAB_SIZE" value="8" />' +
'<option name="USE_TAB_CHARACTER" value="true" /></value></option>' +
'<JSCodeStyleSettings version="0"><option name="USE_SEMICOLON_AFTER_STATEMENT" value="false" /></JSCodeStyleSettings>' +
'<codeStyleSettings language="TypeScript"><option name="SPACE_WITHIN_BRACKETS" value="true" />' +
'<indentOptions><option name="INDENT_SIZE" value="2" /><option name="CONTINUATION_INDENT_SIZE" value="2" />' +
'<option name="TAB_SIZE" value="2" /></indentOptions></codeStyleSettings>' +
'<codeStyleSettings language="HTML"><option name="LINE_COMMENT_AT_FIRST_COLUMN" value="false" />' +
'<indentOptions><option name="USE_TAB_CHARACTER" value="true" /></indentOptions></codeStyleSettings>' +
'<codeStyleSettings language="Brainfuck"><indentOptions><option name="INDENT_SIZE" value="3" /></indentOptions></codeStyleSettings>',
),
},
},
{
...settings,
editor: {
...settings.editor,
codeStyle: { languages: { typescript: { hardWrapAt: 90 }, go: { tabSize: 8 } } },
},
},
);
expect(plan.writes).toEqual([
["editor.codeStyle.hardWrapAt", 100],
["editor.tabSize", 8],
["editor.insertSpaces", false],
[
"editor.codeStyle.languages",
{
typescript: { hardWrapAt: 90, indent: 2, tabSize: 2 },
typescriptreact: { indent: 2, tabSize: 2 },
html: { useTab: true, lineCommentAtFirstColumn: false },
go: { tabSize: 8 },
},
],
]);
expect(plan.rows).toContainEqual({ label: "Code Style › TypeScript", value: "Indent 2, Tab size 2" });
expect(plan.rows).toContainEqual({ label: "Use tab character", value: "On" });
expect(plan.skipped).toEqual(["Code Style options other than Tabs and Indents"]);
});
it("imports the editor options that have a setting here", async () => {
const xml =
"<application>" +
component("EditorSettings", {
IS_SMOOTH_CARET_BLINKING: "true",
IS_BLOCK_CURSOR: "true",
ARE_LINE_NUMBERS_SHOWN: "false",
LINE_NUMERATION: "HYBRID",
SHOW_BREADCRUMBS_ABOVE: "true",
CARET_BLINKING_PERIOD: "700",
IS_ANIMATED_SCROLLING: "false",
}).replace(/<\/?application>/g, "") +
component("CodeInsightSettings", {
AUTOINSERT_PAIR_QUOTE: "false",
REFORMAT_ON_PASTE: "2",
SMART_BACKSPACE: "1",
PARAMETER_INFO_DELAY: "500",
COMPLETION_CASE_SENSITIVE: "2",
}).replace(/<\/?application>/g, "") +
"</application>";
const plan = await planJetBrainsImport({ entries: [], files: { "options/editor.xml": xml } }, settings);
expect(Object.fromEntries(plan.writes)).toEqual({
"editor.appearance.lineNumberMode": "hybrid",
"editor.breadcrumbs.placement": "top",
"editor.appearance.smoothCaretBlinking": true,
"editor.appearance.blockCaret": true,
"editor.appearance.lineNumbers": false,
"editor.appearance.caretBlinkPeriod": 700,
"editor.smartKeys.pairQuotes": false,
"editor.completion.parameterInfoDelay": 500,
"editor.smartKeys.reformatOnPaste": "indentBlock",
"editor.smartKeys.backspaceUnindent": "nearest",
});
expect(plan.rows).toContainEqual({ label: "Unindent", value: "To nearest indent position" });
expect(plan.rows).toContainEqual({ label: "Show line numbers", value: "Hybrid" });
});
it("skips colour schemes that cannot be read", async () => {
const plan = await planJetBrainsImport({ entries: [], files: { "colors/broken.icls": "<nope" } }, settings);
it("skips colour schemes that cannot be read", () => {
const plan = planJetBrainsImport({ entries: [], files: { "colors/broken.icls": "<nope" } }, editor);
expect(plan.invalid).toEqual(["broken.icls"]);
expect(plan.writes).toEqual([]);
});
+2 -5
Переглянути файл
@@ -4,7 +4,7 @@ import { act, fireEvent, render, screen } from "@testing-library/react";
const read = vi.fn();
const set = vi.fn();
const notify = vi.fn();
const editor = { fontFamily: "JetBrains Mono", fontSize: 13, customSchemes: {}, colorOverrides: {} };
const editor = { fontSize: 13, customSchemes: {}, colorOverrides: {} };
vi.mock("@/platform/ipc", async (original) => {
const actual = await original<typeof import("@/platform/ipc")>();
@@ -44,8 +44,6 @@ beforeEach(() => {
},
});
set.mockResolvedValue({ status: "ok", data: { editor } });
// jsdom has no canvas: the import falls back to the font size for the line height.
vi.spyOn(HTMLCanvasElement.prototype, "getContext").mockReturnValue(null);
});
it.each(["Cancel", "Import"])("confirms folder settings before applying them: %s", async (button) => {
@@ -58,7 +56,7 @@ it.each(["Cancel", "Import"])("confirms folder settings before applying them: %s
expect(screen.getByText("Monaco")).toBeInTheDocument();
expect(screen.getByText("17")).toBeInTheDocument();
expect(screen.getAllByText("Custom")).toHaveLength(2);
expect(screen.getByText(/Not imported:/)).toHaveTextContent("Plugins");
expect(screen.getByText(/Not imported:/)).toHaveTextContent("Keymap, Plugins");
expect(set).not.toHaveBeenCalled();
await act(async () => {
fireEvent.click(screen.getByRole("button", { name: button }));
@@ -80,7 +78,6 @@ it.each(["Cancel", "Import"])("confirms folder settings before applying them: %s
"editor.colorScheme": id,
"editor.fontFamily": "Monaco",
"editor.fontSize": 17,
"editor.lineHeight": 25,
});
expect(notify).toHaveBeenCalledWith(expect.objectContaining({ title: "Settings imported" }));
}
-79
Переглянути файл
@@ -15,7 +15,6 @@ import {
installMenuBridge,
menuAccelerator,
menuActionIds,
returnFocusAfterMenu,
routeMenuEvent,
} from "../menuBridge";
@@ -55,84 +54,6 @@ describe("menu state from the frontend", () => {
}
});
it("pushes enablement once when the window loses focus, for its Settings window (#3625)", async () => {
vi.useFakeTimers();
vi.spyOn(ipc, "isTauri").mockReturnValue(true);
const hasFocus = vi.spyOn(document, "hasFocus").mockReturnValue(true);
vi.spyOn(ipc.commands, "appBuildInfo").mockRejectedValue(new Error("No build info in tests"));
vi.spyOn(ipc.commands, "menuConfigure").mockResolvedValue();
vi.spyOn(ipc.commands, "menuModel").mockResolvedValue([
{ kind: "action", id: "test.menuBlur", label: "Test", hint: null, arg: null, checked: null },
]);
const pushDisabled = vi.spyOn(ipc.commands, "menuSetDisabled").mockResolvedValue();
const offAction = registerAction({ id: "test.menuBlur", title: "Test", when: "testMenuBlurEditor", run: () => {} });
setContext("testMenuBlurEditor", true);
const dispose = installMenuBridge();
try {
await vi.advanceTimersByTimeAsync(120);
expect(pushDisabled).toHaveBeenCalledExactlyOnceWith([]);
pushDisabled.mockClear();
// Focus moves to the Settings window: the editor loses focus, then the window blurs.
hasFocus.mockReturnValue(false);
setContext("testMenuBlurEditor", false);
window.dispatchEvent(new Event("blur"));
await vi.advanceTimersByTimeAsync(120);
expect(pushDisabled).toHaveBeenCalledExactlyOnceWith(["test.menuBlur"]);
pushDisabled.mockClear();
// Later changes in a background window are not pushed.
setContext("testMenuBlurEditor", true);
await vi.advanceTimersByTimeAsync(120);
expect(pushDisabled).not.toHaveBeenCalled();
} finally {
dispose();
offAction();
clearContext("testMenuBlurEditor");
vi.useRealTimers();
vi.restoreAllMocks();
}
});
it("brings Settings back once the dialog opened from its menu closes (#3625)", async () => {
vi.useFakeTimers();
vi.spyOn(document, "hasFocus").mockReturnValue(true);
const focusSettings = vi.fn(async () => {});
try {
// About opens a dialog: Settings waits under it.
const about = returnFocusAfterMenu(
Promise.resolve(true)
.then(() => setContext("popupOpen", true))
.then(() => true),
focusSettings,
);
await vi.advanceTimersByTimeAsync(1000);
expect(focusSettings).not.toHaveBeenCalled();
setContext("popupOpen", false);
await about;
expect(focusSettings).toHaveBeenCalledOnce();
// An action that opens nothing: Settings comes back right away.
focusSettings.mockClear();
const saveAll = returnFocusAfterMenu(Promise.resolve(true), focusSettings);
await vi.advanceTimersByTimeAsync(300);
await saveAll;
expect(focusSettings).toHaveBeenCalledOnce();
// Focus moved on (a new window or a native dialog): Settings stays where it is.
focusSettings.mockClear();
vi.mocked(document.hasFocus).mockReturnValue(false);
const open = returnFocusAfterMenu(Promise.resolve(true), focusSettings);
await vi.advanceTimersByTimeAsync(300);
await open;
expect(focusSettings).not.toHaveBeenCalled();
} finally {
clearContext("popupOpen");
vi.useRealTimers();
vi.restoreAllMocks();
}
});
it("lists registered tool windows by title and saved layouts", () => {
localStorage.clear();
_reloadLayouts();
-2
Переглянути файл
@@ -8,8 +8,6 @@ vi.mock("@tauri-apps/api/core", () => ({
Channel: class {
onmessage: (p: unknown) => void = () => {};
},
// Balloons are mirrored to a system notification (`showSystemNotification`).
invoke: async () => null,
}));
type Channel = { onmessage: (p: UpdateProgress) => void };
-50
Переглянути файл
@@ -748,53 +748,3 @@ describe("explicit project-window requests", () => {
}
});
});
describe("trust is asked before a new project window opens", () => {
const openProjectPath = (arg: unknown) =>
windowActions()
.find((a) => a.id === "file.openProjectPath")!
.run({ arg } as never);
const newWindowEntries: [string, () => unknown][] = [
["Open… from a project window", () => openProjectInWindow("/p/b", false)],
["Open in New Window", () => openProjectInWindow("/p/b", true)],
["Open project in: New Window", () => openProjectWithPolicy("/p/b")],
["a plugin's new-window request", () => openProjectPath({ path: "/p/b", newWindow: true })],
];
it.each(newWindowEntries)("%s asks in this window first", async (_, open) => {
useProject.setState({ ...projectState("/p/a"), settings: { general: { openProjectIn: "new" } } } as never);
windowOpenProject.mockResolvedValue(ok({ kind: "opened", label: "project-1" }));
await open();
expect(confirmProjectTrust).toHaveBeenCalledWith("/p/b", "local");
expect(vi.mocked(confirmProjectTrust).mock.invocationCallOrder[0]).toBeLessThan(
windowOpenProject.mock.invocationCallOrder[0]!,
);
expect(windowOpenProject).toHaveBeenCalledWith("/p/b", true, []);
});
it.each(newWindowEntries)("%s opens no window when the user chooses Don't Open", async (_, open) => {
useProject.setState({ ...projectState("/p/a"), settings: { general: { openProjectIn: "new" } } } as never);
vi.mocked(confirmProjectTrust).mockRejectedValueOnce(new IpcError({ kind: "cancelled", message: "Cancelled" }));
await open();
expect(windowOpenProject).not.toHaveBeenCalled();
expect(notify).not.toHaveBeenCalled();
expect(useProject.getState().project?.root).toBe("/p/a");
});
it("leaves a WSL folder to the remote window, which asks about the distribution's project", async () => {
useProject.setState(projectState("/p/a") as never);
wslResolve.mockResolvedValue({ target: { kind: "wsl", distro: "Debian" }, path: "/srv/app" });
windowOpenProject.mockResolvedValue(ok({ kind: "opened", label: "project-1" }));
await openProjectInWindow("\\\\wsl.localhost\\Debian\\srv\\app", true);
expect(confirmProjectTrust).not.toHaveBeenCalled();
expect(windowOpenProject).toHaveBeenCalled();
});
it("asks only once, from openProject, when the project opens in this window", async () => {
windowOpenProject.mockResolvedValue(ok({ kind: "current" }));
await openProjectInWindow("/p/b", false);
expect(windowOpenProject).toHaveBeenCalledWith("/p/b", false, []);
expect(confirmProjectTrust).not.toHaveBeenCalled();
expect(openProject).toHaveBeenCalledWith("/p/b");
});
});
-123
Переглянути файл
@@ -1,123 +0,0 @@
/**
* JetBrains option names (as the IDE writes them to `options/editor.xml` and
* `codestyles/*.xml`) and the OpenIDEA settings of the same meaning. Each entry
* carries the label the option has in Settings, for the import confirmation.
*/
type Mapped = readonly [key: string, label: string];
/** `<component name="EditorSettings">`: on/off options. */
export const EDITOR_FLAGS: Record<string, Mapped> = {
IS_WHEEL_FONTCHANGE_ENABLED: ["editor.general.wheelZoom", "Change font size with Ctrl/Command+Mouse Wheel"],
IS_DND_ENABLED: ["editor.general.dragAndDrop", "Enable drag-and-drop functionality in editor"],
USE_CUSTOM_SOFT_WRAP_INDENT: ["editor.general.softWrapIndent", "Use original line's indent for wrapped parts"],
ADDITIONAL_PAGE_AT_BOTTOM: ["editor.general.scrollPastEnd", "Show virtual space at file bottom"],
KEEP_TRAILING_SPACE_ON_CARET_LINE: ["editor.general.keepTrailingOnCaretLine", "Keep trailing spaces on caret line"],
REMOVE_TRAILING_BLANK_LINES: [
"editor.general.removeTrailingBlankLines",
"Remove trailing blank lines at the end of saved files",
],
IS_CARET_BLINKING: ["editor.appearance.caretBlinking", "Caret blinking (ms):"],
IS_SMOOTH_CARET_BLINKING: ["editor.appearance.smoothCaretBlinking", "Use smooth caret blinking"],
IS_BLOCK_CURSOR: ["editor.appearance.blockCaret", "Use block caret"],
IS_SMOOTH_CARET_MOVEMENT: ["editor.appearance.smoothCaretMovement", "Use smooth caret movement"],
IS_RIGHT_MARGIN_SHOWN: [
"editor.appearance.hardWrapGuides",
"Show hard wrap and visual guides (configured in Code Style options)",
],
ARE_LINE_NUMBERS_SHOWN: ["editor.appearance.lineNumbers", "Show line numbers"],
IS_LEADING_WHITESPACES_SHOWN: ["editor.appearance.whitespaceLeading", "Leading"],
IS_INNER_WHITESPACES_SHOWN: ["editor.appearance.whitespaceInner", "Inner"],
IS_TRAILING_WHITESPACES_SHOWN: ["editor.appearance.whitespaceTrailing", "Trailing"],
IS_INDENT_GUIDES_SHOWN: ["editor.appearance.indentGuides", "Show indent guides"],
SHOW_INTENTION_BULB: ["editor.appearance.intentionBulb", "Show intention bulb"],
ENABLE_RENDERED_DOC: ["editor.appearance.renderDocComments", "Render documentation comments"],
SHOW_BREADCRUMBS: ["editor.breadcrumbs.show", "Show breadcrumbs:"],
IS_FOLDING_OUTLINE_SHOWN: ["editor.folding.showOutline", "Show code folding outline"],
SMART_HOME: ["editor.smartKeys.smartHome", "Home moves caret to first non-whitespace character"],
IS_CAMEL_WORDS: ["editor.smartKeys.camelHumps", 'Use "CamelHumps" words'],
IS_HIGHLIGHT_SELECTION_OCCURRENCES: ["editor.codeEditing.highlightSelection", "Occurrences of selected text"],
SHOW_QUICK_DOC_ON_MOUSE_OVER_ELEMENT: ["editor.codeEditing.quickDocOnHover", "Show quick documentation on hover"],
INSERT_PARENTHESES_AUTOMATICALLY: [
"editor.completion.insertParentheses",
"Insert parentheses automatically when applicable",
],
};
/** `<component name="EditorSettings">`: numbers. */
export const EDITOR_NUMBERS: Record<string, Mapped> = {
CARET_BLINKING_PERIOD: ["editor.appearance.caretBlinkPeriod", "Caret blinking (ms):"],
STICKY_LINES_LIMIT: ["editor.codeEditing.stickyLinesMax", "Maximum number of lines"],
TOOLTIPS_DELAY_MS: ["editor.codeEditing.quickDocDelay", "Tooltip delay"],
};
/** `<component name="CodeInsightSettings">`: on/off options. */
export const CODE_INSIGHT_FLAGS: Record<string, Mapped> = {
AUTOINSERT_PAIR_BRACKET: ["editor.smartKeys.pairBrackets", "Insert paired brackets (), [], {}"],
AUTOINSERT_PAIR_QUOTE: ["editor.smartKeys.pairQuotes", "Insert pair quote"],
SURROUND_SELECTION_ON_QUOTE_TYPED: [
"editor.smartKeys.surroundSelection",
"Surround selection on typing quote or brace",
],
TAB_EXITS_BRACKETS_AND_QUOTES: ["editor.smartKeys.tabOutOfPair", "Jump outside closing bracket/quote with Tab"],
SMART_INDENT_ON_ENTER: ["editor.smartKeys.smartIndent", "Smart indent"],
JAVADOC_STUB_ON_ENTER: ["editor.smartKeys.insertDocStub", "Insert documentation comment stub"],
HIGHLIGHT_IDENTIFIER_UNDER_CARET: ["editor.codeEditing.highlightUsages", "Usages of element at caret"],
HIGHLIGHT_BRACES: ["editor.codeEditing.highlightBraces", "Matched brace"],
AUTO_POPUP_COMPLETION_LOOKUP: ["editor.completion.autoPopup", "Show suggestions as you type"],
AUTOCOMPLETE_ON_CODE_COMPLETION: ["editor.completion.autoInsertSingle", "Automatically insert single suggestions"],
AUTO_POPUP_JAVADOC_INFO: ["editor.completion.showDocumentation", "Show the documentation popup in"],
AUTO_POPUP_PARAMETER_INFO: ["editor.completion.parameterInfo", "Show the parameter info popup in"],
};
/** `<component name="CodeInsightSettings">`: numbers. */
export const CODE_INSIGHT_NUMBERS: Record<string, Mapped> = {
JAVADOC_INFO_DELAY: ["editor.completion.documentationDelay", "Show the documentation popup in"],
PARAMETER_INFO_DELAY: ["editor.completion.parameterInfoDelay", "Show the parameter info popup in"],
};
/** `REFORMAT_ON_PASTE` (IDEA's `CodeInsightSettings` constants) → `editor.smartKeys.reformatOnPaste`, its label. */
export const REFORMAT_ON_PASTE: Record<string, Mapped> = {
"1": ["none", "None"],
"2": ["indentBlock", "Indent Block"],
"3": ["indentEachLine", "Indent Each Line"],
};
/** `SMART_BACKSPACE` (IDEA's `SmartBackspaceMode` ordinals) → `editor.smartKeys.backspaceUnindent`, its label. */
export const SMART_BACKSPACE: Record<string, Mapped> = {
"0": ["none", "Disabled"],
"1": ["nearest", "To nearest indent position"],
"2": ["autoindent", "To proper indent position"],
};
/** `<codeStyleSettings language=…>` → the language ids that share that code style here. */
export const CODE_STYLE_LANGUAGES: Record<string, readonly string[]> = {
JAVA: ["java"],
kotlin: ["kotlin"],
Groovy: ["groovy"],
Scala: ["scala"],
JavaScript: ["javascript", "javascriptreact"],
TypeScript: ["typescript", "typescriptreact"],
Vue: ["vue"],
HTML: ["html"],
XML: ["xml"],
CSS: ["css"],
SCSS: ["scss"],
SASS: ["sass"],
LESS: ["less"],
JSON: ["json", "jsonc"],
yaml: ["yaml"],
TOML: ["toml"],
Markdown: ["markdown"],
Python: ["python"],
go: ["go"],
Rust: ["rust"],
PHP: ["php"],
ruby: ["ruby"],
Dart: ["dart"],
Swift: ["swift"],
"C#": ["csharp"],
Lua: ["lua"],
SQL: ["sql"],
"Shell Script": ["shellscript"],
};
+18 -228
Переглянути файл
@@ -1,32 +1,20 @@
/**
* Import Settings… with a JetBrains `settings.zip`: maps the archive's colour
* schemes, keymaps, fonts, tabs and indents, and the editor / general options
* OpenIDEA has to settings writes, after a confirmation listing them. Only keys
* present in the archive are written (JetBrains leaves defaults out). The rest
* is listed as not imported.
* schemes and the editor / general options OpenIDEA has to settings writes, after
* a confirmation listing them. Only keys present in the archive are written
* (JetBrains leaves defaults out). Keymaps, code styles and the rest are listed
* as not imported.
*/
import { Fragment } from "react";
import type { CustomKeymap, JetBrainsSettings, LanguageCodeStyle } from "@/bindings";
import type { JetBrainsSettings } from "@/bindings";
import { customSchemes } from "@/platform/colorScheme";
import { createFontProbeCanvas, fontsLoaded, monoFontFamily } from "@/platform/fonts";
import { tx } from "@/platform/i18n";
import { importScheme, parseIcls } from "@/platform/icls";
import { addIdeaKeymap, parseIdeaKeymap } from "@/platform/ideaKeymap";
import { call, commands } from "@/platform/ipc";
import { guessOs } from "@/platform/platformInfo";
import { useProject } from "@/platform/project";
import { notifications } from "@/workbench/contributions";
import { ask } from "@/workbench/messages";
import styles from "./app.module.css";
import {
CODE_INSIGHT_FLAGS,
CODE_INSIGHT_NUMBERS,
CODE_STYLE_LANGUAGES,
EDITOR_FLAGS,
EDITOR_NUMBERS,
REFORMAT_ON_PASTE,
SMART_BACKSPACE,
} from "./jetbrainsOptions";
export interface JetBrainsImportPlan {
/** Settings writes, in order: `settingsSet("global", key, JSON.stringify(value))`. */
@@ -35,22 +23,14 @@ export interface JetBrainsImportPlan {
rows: { label: string; value: string }[];
/** Categories present in the archive that are not imported (translated). */
skipped: string[];
/** Colour scheme and keymap files that could not be read. */
/** `.icls` files that could not be read. */
invalid: string[];
/** IDEA action ids the imported keymaps bind that have no counterpart here. */
unknownActions: string[];
}
/** The settings the import builds on (`settingsGetGlobal`). */
interface CurrentSettings {
editor: {
fontFamily: string;
fontSize: number | null;
customSchemes: unknown;
colorOverrides: Record<string, unknown>;
codeStyle?: { languages?: Record<string, LanguageCodeStyle> };
};
customKeymaps?: Record<string, CustomKeymap>;
interface EditorState {
fontSize: number | null;
customSchemes: unknown;
colorOverrides: Record<string, unknown>;
}
const USER_PREFIX = "_@user_";
@@ -83,67 +63,8 @@ const num = (v: string | undefined) => {
const onOff = (v: boolean) => (v ? tx("On") : tx("Off"));
/** IDEA's `LINE_SPACING` when the export leaves it out. */
const DEFAULT_LINE_SPACING = 1.2;
/** The font's own line height in px, as IDEA's editor takes it from Java's FontMetrics. */
export type FontHeight = (family: string, size: number) => Promise<number | undefined> | number | undefined;
/** WebKit reports whole-pixel metrics; measured this large, they keep the font's fractions. */
const PROBE_SIZE = 1000;
async function measuredFontHeight(family: string, size: number): Promise<number | undefined> {
// The editor's own stack: WKWebView draws an installed font only through its loaded alias.
const stack = monoFontFamily(family);
await fontsLoaded(stack, size);
const canvas = createFontProbeCanvas();
try {
const ctx = canvas.getContext("2d");
if (!ctx) return undefined;
ctx.font = `${PROBE_SIZE}px ${stack}`;
const m = ctx.measureText("M");
// Java rounds the ascent and the descent up separately (anything past .05 of a pixel).
const px = (v: number) => Math.floor((v / PROBE_SIZE) * size + 0.95);
const h = px(m.fontBoundingBoxAscent) + px(m.fontBoundingBoxDescent);
return Number.isFinite(h) && h > 0 ? h : undefined;
} finally {
canvas.remove();
}
}
/** `<option name value>` children of `parent`. */
function optionValues(parent: Element | null | undefined): Map<string, string> {
const out = new Map<string, string>();
for (const o of Array.from(parent?.children ?? [])) {
const name = o.getAttribute("name");
const value = o.getAttribute("value");
if (o.tagName === "option" && name && value !== null) out.set(name, value);
}
return out;
}
const childOf = (parent: Element, tag: string, name?: string) =>
Array.from(parent.children).find((c) => c.tagName === tag && (name === undefined || c.getAttribute("name") === name));
/** The code style scheme called `name` among `codestyles/*.xml`. */
function codeScheme(files: Record<string, string>, name: string): Element | undefined {
for (const [file, text] of Object.entries(files)) {
if (!file.startsWith("codestyles/")) continue;
const doc = new DOMParser().parseFromString(text, "application/xml");
const root = doc.documentElement;
if (!doc.querySelector("parsererror") && root.tagName === "code_scheme" && root.getAttribute("name") === name)
return root;
}
return undefined;
}
export async function planJetBrainsImport(
bundle: JetBrainsSettings,
current: CurrentSettings,
fontHeight: FontHeight = measuredFontHeight,
): Promise<JetBrainsImportPlan> {
const { editor } = current;
const plan: JetBrainsImportPlan = { writes: [], rows: [], skipped: [], invalid: [], unknownActions: [] };
export function planJetBrainsImport(bundle: JetBrainsSettings, editor: EditorState): JetBrainsImportPlan {
const plan: JetBrainsImportPlan = { writes: [], rows: [], skipped: [], invalid: [] };
const add = (key: string, value: string | number | boolean | undefined, label: string, shown?: string) => {
if (value === undefined) return;
plan.writes.push([key, value]);
@@ -179,63 +100,15 @@ export async function planJetBrainsImport(
if (id) add("editor.colorScheme", id, tx("Current color scheme"), customs[id]?.name);
}
let keymaps = current.customKeymaps ?? {};
const importedKeymaps = new Map<string, string>(); // name in the keymap file → keymap id
for (const [file, text] of Object.entries(bundle.files)) {
if (!file.startsWith("keymaps/")) continue;
let parsed;
try {
parsed = parseIdeaKeymap(text);
} catch {
plan.invalid.push(file.slice("keymaps/".length));
continue;
}
// Overwrites an earlier import of the same keymap, as colour schemes do.
const next = addIdeaKeymap(keymaps, parsed);
keymaps = next.customs;
importedKeymaps.set(parsed.name, next.id);
plan.unknownActions.push(...parsed.unknownActions.filter((id) => !plan.unknownActions.includes(id)));
plan.rows.push({ label: tx("Keymap"), value: keymaps[next.id]?.name ?? parsed.name });
}
if (importedKeymaps.size) {
plan.writes.push(["customKeymaps", keymaps]);
// The active keymap is stored per operating system; a bundled one keeps OpenIDEA's choice.
const os = { macos: "mac", windows: "windows", linux: "linux", web: "" }[guessOs()];
const active = options(bundle.files[`options/${os}/keymap.xml`], "KeymapManager", "active_keymap").get("");
const id = importedKeymaps.get(active ?? "");
if (id) add("keymap", id, tx("Current keymap"), keymaps[id]?.name);
}
const font = options(bundle.files["options/editor-font.xml"], "DefaultFont");
const family = font.get("FONT_FAMILY")?.trim() || undefined;
add("editor.fontFamily", family, tx("Font"));
add("editor.fontFamily", font.get("FONT_FAMILY")?.trim() || undefined, tx("Font"));
const size = num(font.get("FONT_SIZE"));
add("editor.fontSize", size, tx("Size"));
const spacing = num(font.get("LINE_SPACING"));
// IDEA spaces lines by the font's own height, not its size, so a tall font keeps its
// spacing; and the default spacing still applies when only the font changed.
const base = size ?? editor.fontSize;
if (base && (family || size || spacing)) {
const natural = (await fontHeight(family ?? editor.fontFamily, base)) ?? base * DEFAULT_LINE_SPACING;
add("editor.lineHeight", Math.ceil(natural * (spacing ?? DEFAULT_LINE_SPACING)), tx("Line height"));
}
add("editor.lineHeight", spacing && base ? Math.round(base * spacing) : undefined, tx("Line height"));
add("editor.ligatures", bool(font.get("USE_LIGATURES")), tx("Enable ligatures"));
const terminal = options(bundle.files["options/terminal-font.xml"], "TerminalFontOptions");
const terminalFamily = terminal.get("FONT_FAMILY")?.trim() || undefined;
const terminalSize = num(terminal.get("FONT_SIZE"));
// A terminal font of its own: stop following the editor font (the font rows below say so).
if (terminalFamily || terminalSize) plan.writes.push(["terminal.useEditorFont", false]);
add("terminal.fontFamily", terminalFamily, tx("Terminal font"));
add("terminal.fontSize", terminalSize, tx("Terminal font size"));
add("terminal.lineHeight", num(terminal.get("LINE_SPACING")), tx("Terminal line height"));
add("terminal.columnWidth", num(terminal.get("COLUMN_SPACING")), tx("Terminal column width"));
add(
"terminal.fallbackFontFamily",
terminal.get("SECONDARY_FONT_FAMILY")?.trim() || undefined,
tx("Terminal fallback font"),
);
const ed = options(bundle.files["options/editor.xml"], "EditorSettings");
const strip = ed.get("STRIP_TRAILING_SPACES"); // None | Changed | Whole
if (strip === "Changed" || strip === "Whole") {
@@ -262,95 +135,13 @@ export async function planJetBrainsImport(
wraps === undefined ? undefined : wraps.split(",").includes("MAIN_EDITOR"),
tx("Soft-wrap files"),
);
add(
"console.softWrap",
wraps === undefined ? undefined : wraps.split(",").includes("CONSOLE"),
tx("Use soft wraps in console"),
);
add("editor.general.softWrapFiles", ed.get("SOFT_WRAP_FILE_MASKS")?.trim() || undefined, tx("File patterns"));
const numeration = { ABSOLUTE: "Absolute", RELATIVE: "Relative", HYBRID: "Hybrid" }[ed.get("LINE_NUMERATION") ?? ""];
add("editor.appearance.lineNumberMode", numeration?.toLowerCase(), tx("Show line numbers"), tx(numeration ?? ""));
const above = bool(ed.get("SHOW_BREADCRUMBS_ABOVE"));
add(
"editor.breadcrumbs.placement",
above === undefined ? undefined : above ? "top" : "bottom",
tx("Show breadcrumbs:"),
tx(above ? "Top" : "Bottom"),
);
const insight = options(bundle.files["options/editor.xml"], "CodeInsightSettings");
for (const [source, flags, numbers] of [
[ed, EDITOR_FLAGS, EDITOR_NUMBERS],
[insight, CODE_INSIGHT_FLAGS, CODE_INSIGHT_NUMBERS],
] as const) {
for (const [name, [key, label]] of Object.entries(flags)) add(key, bool(source.get(name)), tx(label));
for (const [name, [key, label]] of Object.entries(numbers)) add(key, num(source.get(name)), tx(label));
}
const paste = REFORMAT_ON_PASTE[insight.get("REFORMAT_ON_PASTE") ?? ""];
add("editor.smartKeys.reformatOnPaste", paste?.[0], tx("Reformat on paste"), tx(paste?.[1] ?? ""));
const backspace = SMART_BACKSPACE[insight.get("SMART_BACKSPACE") ?? ""];
add("editor.smartKeys.backspaceUnindent", backspace?.[0], tx("Unindent"), tx(backspace?.[1] ?? ""));
// Tabs and Indents of the current code style scheme; its other formatting options have no setting here.
const schemeName =
options(bundle.files["options/code.style.schemes.xml"], "CodeStyleSchemeSettings").get("CURRENT_SCHEME_NAME") ??
"Default";
const scheme = codeScheme(bundle.files, schemeName);
if (scheme) {
const root = optionValues(scheme);
add("editor.codeStyle.hardWrapAt", num(root.get("RIGHT_MARGIN")), tx("Hard wrap at"));
add(
"editor.codeStyle.detectIndents",
bool(root.get("AUTODETECT_INDENTS")),
tx("Detect and use existing file indents for editing"),
);
// "Other File Types": the indent of languages without a code style of their own.
const other = optionValues(childOf(childOf(scheme, "option", "OTHER_INDENT_OPTIONS") ?? scheme, "value"));
add("editor.tabSize", num(other.get("TAB_SIZE")), tx("Tab size"));
const otherTabs = bool(other.get("USE_TAB_CHARACTER"));
add(
"editor.insertSpaces",
otherTabs === undefined ? undefined : !otherTabs,
tx("Use tab character"),
otherTabs === undefined ? undefined : onOff(otherTabs),
);
const languages = { ...editor.codeStyle?.languages };
let changed = false;
for (const block of Array.from(scheme.children)) {
const ids = CODE_STYLE_LANGUAGES[block.getAttribute("language") ?? ""];
if (block.tagName !== "codeStyleSettings" || !ids) continue;
const own = optionValues(block);
const indent = optionValues(childOf(block, "indentOptions"));
const style: Partial<LanguageCodeStyle> = {};
const shown: string[] = [];
const set = <K extends keyof LanguageCodeStyle>(
key: K,
value: LanguageCodeStyle[K] | undefined,
label: string,
) => {
if (value === undefined) return;
style[key] = value;
shown.push(`${tx(label)} ${typeof value === "boolean" ? onOff(value) : value}`);
};
set("indent", num(indent.get("INDENT_SIZE")), "Indent");
set("tabSize", num(indent.get("TAB_SIZE")), "Tab size");
set("useTab", bool(indent.get("USE_TAB_CHARACTER")), "Use tab character");
set("hardWrapAt", num(own.get("RIGHT_MARGIN")), "Hard wrap at");
set("lineCommentAtFirstColumn", bool(own.get("LINE_COMMENT_AT_FIRST_COLUMN")), "Line comment at first column");
set("lineCommentAddSpace", bool(own.get("LINE_COMMENT_ADD_SPACE")), "Add a space at line comment start");
if (!shown.length) continue;
for (const id of ids) languages[id] = { ...languages[id], ...style } as LanguageCodeStyle;
changed = true;
plan.rows.push({ label: `${tx("Code Style")} › ${block.getAttribute("language")}`, value: shown.join(", ") });
}
if (changed) plan.writes.push(["editor.codeStyle.languages", languages]);
}
const general = options(bundle.files["options/ide.general.xml"], "GeneralSettings");
add("general.confirmExit", bool(general.get("confirmExit")), tx("Confirm before exiting the IDE"));
const has = (prefix: string) => bundle.entries.some((e) => e.startsWith(prefix));
if (has("codestyles/")) plan.skipped.push(tx("Code Style options other than Tabs and Indents"));
if (has("keymaps/")) plan.skipped.push(tx("Keymap"));
if (has("codestyles/")) plan.skipped.push(tx("Code Style"));
if (has("templates/")) plan.skipped.push(tx("Live templates"));
if (has("inspection/")) plan.skipped.push(tx("Inspections"));
if (has("installed.txt")) plan.skipped.push(tx("Plugins"));
@@ -359,7 +150,6 @@ export async function planJetBrainsImport(
function Summary({ plan }: { plan: JetBrainsImportPlan }) {
const left = [...plan.skipped, ...plan.invalid];
const unknown = plan.unknownActions;
return (
<div className={styles.importSummary}>
<div>{tx("These settings will be imported:")}</div>
@@ -376,7 +166,6 @@ function Summary({ plan }: { plan: JetBrainsImportPlan }) {
{tx("Not imported:")} {left.join(", ")}
</div>
)}
{unknown.length > 0 && <div>{tx`Not available in OpenIDEA (${unknown.length}): ${unknown.join(", ")}.`}</div>}
</div>
);
}
@@ -384,7 +173,8 @@ function Summary({ plan }: { plan: JetBrainsImportPlan }) {
/** Reads `path`, asks, then writes the mapped settings to the global layer. */
export async function importJetBrainsSettings(path: string) {
const bundle = await call(commands.settingsReadJetbrains(path));
const plan = await planJetBrainsImport(bundle, await commands.settingsGetGlobal());
const { editor } = await commands.settingsGetGlobal();
const plan = planJetBrainsImport(bundle, editor);
if (!plan.writes.length) {
notifications().notify({
level: "warning",
+4 -53
Переглянути файл
@@ -8,7 +8,7 @@
* equivalent while the JS keymap stays the only dispatcher (see src-tauri/src/menu.rs).
*/
import { executeActionFrom, getAction, isActionEnabled, useActions } from "@/platform/actions";
import { getContext, useContextKeys } from "@/platform/context";
import { useContextKeys } from "@/platform/context";
import { keysWithPrefix, t, tx, useI18n } from "@/platform/i18n";
import { commands, isTauri, type DynamicItem, type MenuConfig, type MenuNode } from "@/platform/ipc";
import {
@@ -32,8 +32,6 @@ export const MENU_EVENT = "openidea://menu";
export interface MenuRoute {
action: string;
arg?: string | null;
/** The window in front when the item was chosen, if it is not this one (this window's Settings). */
returnTo?: string;
}
export function isMenuRoute(v: unknown): v is MenuRoute {
@@ -49,36 +47,6 @@ export function routeMenuEvent(
return run(payload.action, payload.arg ?? undefined);
}
/** How long an action chosen from the menu may take to open its dialog or popup. */
const OPEN_DELAY_MS = 300;
const layersClosed = () =>
new Promise<void>((resolve) => {
if (!getContext().popupOpen) return resolve();
const off = useContextKeys.subscribe((ctx) => {
if (ctx.popupOpen) return;
off();
resolve();
});
});
/**
* After an item chosen in this window's Settings window ran here (the backend brought this window
* forward): once the dialog or popup it opened closes, or right away if it opened none, Settings comes
* back to the front, as IDEA's Settings dialog stays under the dialogs opened from the menu. Not when
* focus has moved on (a new window, a native dialog).
*/
export async function returnFocusAfterMenu(
ran: Promise<boolean>,
focusWindow: () => Promise<void>,
delay = OPEN_DELAY_MS,
): Promise<void> {
await ran;
await new Promise((r) => setTimeout(r, delay));
await layersClosed();
if (document.hasFocus()) await focusWindow();
}
/**
* Keymap key names a macOS key equivalent can show. Mirrors the names muda's accelerator
* parser accepts: Tauri drops an accelerator it cannot parse, and the item shows no shortcut.
@@ -199,36 +167,22 @@ export function installMenuBridge(): () => void {
void import("@tauri-apps/api/webviewWindow").then(async ({ getCurrentWebviewWindow }) => {
// Window-scoped: a global `listen` would also receive other windows' menu events.
const off = await getCurrentWebviewWindow().listen(MENU_EVENT, ({ payload }) => {
const ran = routeMenuEvent(payload);
const returnTo = isMenuRoute(payload) ? payload.returnTo : undefined;
if (returnTo)
void returnFocusAfterMenu(ran, async () => {
const { Window } = await import("@tauri-apps/api/window");
await (await Window.getByLabel(returnTo))?.setFocus();
}).catch(() => {});
});
const off = await getCurrentWebviewWindow().listen(MENU_EVENT, ({ payload }) => void routeMenuEvent(payload));
if (disposed) off();
else unlisten = off;
});
// Enablement of the native items follows this window's context (IDEA greys out
// what cannot run). Recomputed shortly after context changes, sent only when it changed.
// Also once on blur: the menu still runs here while this window's Settings window is focused,
// with nothing focused here (editor actions disabled). The backend ignores it for other windows.
let ids: Set<string> | null = null;
let lastDisabled = "";
let forceEnablement = false;
let afterBlur = false;
let enableTimer: ReturnType<typeof setTimeout> | undefined;
const pushEnablement = (force = false, blurred = false) => {
const pushEnablement = (force = false) => {
forceEnablement ||= force;
afterBlur ||= blurred;
clearTimeout(enableTimer);
enableTimer = setTimeout(() => {
const unfocused = !document.hasFocus();
if (!ids || disposed || (unfocused && !afterBlur)) return;
afterBlur = false;
if (!ids || disposed || !document.hasFocus()) return;
const dynamic = Object.values(dynamicMenuItems()).flatMap((items) => items.map((d) => d.action));
const disabled = disabledMenuActions(new Set([...ids, ...dynamic]));
const key = disabled.join(",");
@@ -255,8 +209,6 @@ export function installMenuBridge(): () => void {
// The backend edits only submenus whose visible items changed, so switching project
// tabs does not redraw the macOS menu bar.
window.addEventListener("focus", onFocus);
const onBlur = () => pushEnablement(true, true);
window.addEventListener("blur", onBlur);
const unsubs = [
useI18n.subscribe((s, prev) => {
if (s.messages !== prev.messages) push();
@@ -285,7 +237,6 @@ export function installMenuBridge(): () => void {
clearTimeout(timer);
clearTimeout(enableTimer);
window.removeEventListener("focus", onFocus);
window.removeEventListener("blur", onBlur);
unlisten?.();
unsubs.forEach((u) => u());
};
+2 -13
Переглянути файл
@@ -130,17 +130,6 @@ export async function openPaths(
if (dir) await openProjectWithPolicy(dir);
}
/**
* `window_open_project`. When that may create a window, the trust question is asked here
* first (IntelliJ IDEA asks before the project frame opens): the new window would otherwise
* show its Welcome screen under the question. A WSL folder opens as a remote project, whose
* window asks about the distribution's folder itself.
*/
async function openProjectWindow(path: string, newWindow: boolean, files: readonly string[] = []) {
if (newWindow && !(await commands.wslResolve(path).catch(() => null))) await confirmProjectTrust(path, "local");
return call(commands.windowOpenProject(path, newWindow, [...files]));
}
/**
* Opens `path`, focusing the window that already has it. `newWindow`: always a
* new window; otherwise this window unless it already has a project or LightEdit
@@ -151,7 +140,7 @@ export async function openProjectInWindow(path: string, newWindow: boolean, file
const s = useProject.getState();
const inNew = newWindow || s.project !== null || s.lightEdit;
try {
const outcome = await openProjectWindow(path, inNew, files);
const outcome = await call(commands.windowOpenProject(path, inNew, [...files]));
if (outcome.kind === "current" && (await openHere(path))) await openInEditor(files);
} catch (e) {
openFailed(path, e);
@@ -546,7 +535,7 @@ export function windowActions(): Action[] {
const arg = c.arg as { path?: unknown; newWindow?: unknown } | null;
if (!arg || typeof arg.path !== "string" || typeof arg.newWindow !== "boolean") return;
try {
const outcome = await openProjectWindow(arg.path, arg.newWindow);
const outcome = await call(commands.windowOpenProject(arg.path, arg.newWindow, []));
if (outcome.kind === "current") await openHere(arg.path);
} catch (error) {
openFailed(arg.path, error);
+23 -2
Переглянути файл
@@ -251,8 +251,6 @@
min-height: 0;
display: flex;
flex-direction: column;
/* Data source colours are stronger than file colours. */
--row-tint-strength: var(--tint-strength);
}
.treeHost > * {
flex: 1;
@@ -264,6 +262,29 @@
gap: var(--space-1-5);
min-width: 0;
}
/* The whole tree row, indent included, so a coloured source and its children form one band. */
.tintedRow:not([aria-selected="true"]):not(:hover) {
border-radius: 0;
background: color-mix(in srgb, var(--db-tint) var(--tint-strength), transparent);
}
.tintRed {
--db-tint: var(--db-color-red);
}
.tintOrange {
--db-tint: var(--db-color-orange);
}
.tintYellow {
--db-tint: var(--db-color-yellow);
}
.tintGreen {
--db-tint: var(--db-color-green);
}
.tintBlue {
--db-tint: var(--db-color-blue);
}
.tintViolet {
--db-tint: var(--db-color-violet);
}
.nodeLabel {
overflow: hidden;
text-overflow: ellipsis;
+5 -5
Переглянути файл
@@ -8,6 +8,7 @@ import { tablesKey, useDatabase } from "./store";
import { tableInput } from "./tableInput";
import { useEditorRegistry } from "@/editor/api";
import { provideEditorService, provideToolWindowService, type EditorInput } from "@/workbench/contributions";
import styles from "./Database.module.css";
vi.mock("@tanstack/react-virtual", () => ({
useVirtualizer: ({ count }: { count: number }) => ({
@@ -194,10 +195,9 @@ describe("data source colour", () => {
});
render(<DatabaseView />);
const tree = within(screen.getByRole("tree", { name: "Data sources" }));
const tint = (name: string) =>
tree.getByText(name).closest<HTMLElement>('[role="treeitem"]')!.style.getPropertyValue("--row-tint");
for (const name of ["PostgreSQL", "public", "routines", "refresh_data"])
expect(tint(name)).toBe("var(--db-color-red)");
expect(tint("SQLite")).toBe("");
for (const name of ["PostgreSQL", "public", "routines", "refresh_data"]) {
expect(tree.getByText(name).closest('[role="treeitem"]')).toHaveClass(styles.tintedRow!, styles.tintRed!);
}
expect(tree.getByText("SQLite").closest('[role="treeitem"]')).not.toHaveClass(styles.tintedRow!);
});
});
+12 -3
Переглянути файл
@@ -6,7 +6,7 @@
* source to open its query console.
*/
import { useEffect, useMemo, useRef } from "react";
import type { DbDatabases, DbTableDetails } from "@/platform/ipc";
import type { DbColor, DbDatabases, DbTableDetails } from "@/platform/ipc";
import { executeAction } from "@/platform/actions";
import { shortcutLabel } from "@/platform/keymap";
import {
@@ -55,6 +55,15 @@ import styles from "./Database.module.css";
import { tx } from "@/platform/i18n";
import { databaseRequest } from "./requests";
const ROW_TINTS: Record<DbColor, string | undefined> = {
red: styles.tintRed,
orange: styles.tintOrange,
yellow: styles.tintYellow,
green: styles.tintGreen,
blue: styles.tintBlue,
violet: styles.tintViolet,
};
const GROUP_LABELS: Record<Group, string> = {
columns: "columns",
keys: "keys",
@@ -516,11 +525,11 @@ export function DatabaseView() {
getIcon={(n) => icon(n)}
getDetail={detail}
getColor={(n) => (n.kind === "message" && n.error ? "var(--danger)" : undefined)}
rowTint={(n) => {
rowClassName={(n) => {
// IDEA tints every row of a coloured data source across its full width and height.
const target = nodeTarget(n);
const color = target ? sourceOf(target)?.color : null;
return color ? `var(--db-color-${color})` : undefined;
return color ? `${styles.tintedRow} ${ROW_TINTS[color]}` : undefined;
}}
speedSearchField
renderNode={(n: Node, state) => {
-2
Переглянути файл
@@ -13,7 +13,6 @@ const ObjectDialogs = lazyComponent(() => import("./ObjectDialogs").then((m) =>
const ExportDialog = lazyComponent(() => import("./ExportDialog").then((m) => m.ExportDialog));
const HistoryDialog = lazyComponent(() => import("./DataDialogs").then((m) => m.HistoryDialog));
const ImportDialog = lazyComponent(() => import("./DataDialogs").then((m) => m.ImportDialog));
const SchemaCompareDialog = lazyComponent(() => import("./SchemaCompareDialog").then((m) => m.SchemaCompareDialog));
function PasswordDialog({ source, resolve }: { source: DataSource; resolve: (ok: boolean) => void }) {
const [password, setPassword] = useState("");
@@ -186,7 +185,6 @@ export function DatabaseDialogs() {
if (dialog.kind === "params") return <ParamsDialog names={dialog.names} resolve={dialog.resolve} />;
if (dialog.kind === "export")
return <ExportDialog data={dialog.data} source={dialog.source} initialFormat={dialog.format} />;
if (dialog.kind === "compareSchemas") return <SchemaCompareDialog initial={dialog.source} />;
if (dialog.kind === "history") return <HistoryDialog key={dialog.id} id={dialog.id} path={dialog.path} />;
if (dialog.kind === "import")
return (
-91
Переглянути файл
@@ -1,91 +0,0 @@
.body {
display: flex;
flex-direction: column;
gap: var(--space-2);
height: 560px;
padding: 14px;
}
.pickers {
display: flex;
align-items: center;
gap: var(--space-2);
flex-wrap: wrap;
}
.side {
display: flex;
align-items: center;
gap: var(--space-1);
}
.sideLabel {
color: var(--fg-secondary);
}
.arrow {
color: var(--fg-muted);
}
.toolbar {
display: flex;
align-items: center;
gap: var(--space-2);
}
.spacer {
flex: 1;
}
.count,
.direction {
color: var(--fg-muted);
}
.panes {
display: flex;
gap: var(--space-2);
flex: 1;
min-height: 0;
}
.tree {
display: flex;
flex-direction: column;
flex: 1.2;
min-width: 0;
border: 1px solid var(--border);
border-radius: var(--radius-control);
overflow: hidden;
}
.tree > * {
flex: 1;
min-height: 0;
}
.preview {
flex: 1;
min-width: 0;
}
.row {
display: inline-flex;
align-items: center;
gap: var(--space-1-5);
min-width: 0;
}
.name {
white-space: nowrap;
}
.detail {
overflow: hidden;
color: var(--fg-muted);
text-overflow: ellipsis;
white-space: nowrap;
}
.state {
width: 12px;
font-weight: 600;
text-align: center;
}
.added {
color: var(--vcs-added);
}
.removed {
color: var(--vcs-deleted);
}
.changed {
color: var(--vcs-modified);
}
.same {
color: var(--fg-muted);
}
-334
Переглянути файл
@@ -1,334 +0,0 @@
/**
* Compare Structure (DataGrip's schema comparison): pick a source and a target schema,
* see their differences — tables, columns, indexes, foreign keys — choose the ones to
* migrate and preview the SQL that makes the target match the source. Nothing runs: the
* script is copied or opened in a query console of the target.
*/
import { useEffect, useMemo, useRef, useState } from "react";
import clsx from "clsx";
import { tx } from "@/platform/i18n";
import { Button, Checkbox, Dialog, EmptyState, Icon, Select, Spinner, T, Tree, type SelectOption } from "@/ui";
import { notifications } from "@/workbench/contributions";
import { CodePreview } from "./CodePreview";
import {
diffSchemas,
differenceKeys,
migrationSql,
type DiffState,
type ItemDiff,
type TableDiff,
} from "./schemaCompare";
import {
closeDialog,
loadSchemas,
loadSources,
openConsoleWith,
schemaSnapshot,
sourceById,
targetLabel,
useDatabase,
} from "./store";
import styles from "./SchemaCompare.module.css";
interface Side {
id: string;
schema: string;
}
/** A row of the differences tree: a table, a group of its items, or an item. */
type Row =
| { kind: "table"; key: string; diff: TableDiff }
| { kind: "group"; key: string; label: string; items: ItemDiff<unknown>[]; table: TableDiff }
| { kind: "item"; key: string; diff: ItemDiff<unknown>; table: TableDiff; what: "column" | "index" | "foreignKey" };
const STATE_LABEL: Record<DiffState, string> = {
added: "Only in source",
removed: "Only in target",
changed: "Different",
same: "Identical",
};
function SidePicker({ label, side, onChange }: { label: string; side: Side; onChange: (side: Side) => void }) {
const sources = useDatabase((s) => s.sources);
const schemas = useDatabase((s) => (side.id ? s.schemas[side.id] : undefined));
useEffect(() => {
if (side.id && !useDatabase.getState().schemas[side.id]) void loadSchemas(side.id);
}, [side.id]);
const sourceOptions: SelectOption[] = sources.map((s) => ({
value: s.id ?? "",
label: s.name ?? "",
icon: "database",
}));
if (side.id && !sourceOptions.some((o) => o.value === side.id))
sourceOptions.push({ value: side.id, label: targetLabel(side.id), icon: "database" });
const names = schemas?.status === "ok" ? schemas.value : [];
const schemaOptions: SelectOption[] = names.map((n) => ({ value: n, label: n, icon: "db-schema" }));
if (side.schema && !names.includes(side.schema)) schemaOptions.unshift({ value: side.schema, label: side.schema });
return (
<div className={styles.side}>
<span className={styles.sideLabel}>
<T>{label}</T>
</span>
<Select
aria-label={tx`${tx(label)} data source`}
value={side.id || null}
placeholder="<data source>"
options={sourceOptions}
onChange={(id) => onChange({ id, schema: sourceById(id)?.driver === "sqlite" ? "main" : "" })}
/>
<Select
aria-label={tx`${tx(label)} schema`}
value={side.schema || null}
placeholder="<schema>"
options={schemaOptions}
searchable={schemaOptions.length > 10}
disabled={!side.id}
onChange={(schema) => onChange({ ...side, schema })}
/>
</div>
);
}
function StateIcon({ state }: { state: DiffState }) {
return (
<span
className={clsx(styles.state, styles[state])}
title={tx(STATE_LABEL[state])}
aria-label={tx(STATE_LABEL[state])}
>
{state === "added" ? "+" : state === "removed" ? "−" : state === "changed" ? "≠" : "="}
</span>
);
}
function itemDetail(row: Extract<Row, { kind: "item" }>): string {
const d = row.diff;
if (row.what === "column") {
const c = (x: unknown) => x as { dataType: string; nullable: boolean; default: string | null } | undefined;
const s = c(d.source);
const t = c(d.target);
const text = (x: ReturnType<typeof c>) =>
x ? `${x.dataType}${x.nullable ? "" : " not null"}${x.default ? ` default ${x.default}` : ""}` : "";
if (d.state === "changed") return `${text(t)} → ${text(s)}`;
return text(s ?? t);
}
if (row.what === "index") {
const i = (d.source ?? d.target) as { unique: boolean; columns: string[] };
return `${i.unique ? "unique " : ""}(${i.columns.join(", ")})`;
}
return "";
}
/** The direction of the migration, said in the footer. */
function migrates(source: Side, target: Side): string {
const from = `${targetLabel(source.id)}.${source.schema}`;
const to = `${targetLabel(target.id)}.${target.schema}`;
return tx`Migrates ${to} to match ${from}`;
}
function includeLabel(r: Row): string {
const name = r.kind === "group" ? tx(r.label) : r.diff.name;
return tx`Include ${name}`;
}
export function SchemaCompareDialog({ initial }: { initial: Side | null }) {
const [source, setSource] = useState<Side>(initial ?? { id: "", schema: "" });
const [target, setTarget] = useState<Side>({ id: "", schema: "" });
const [diffs, setDiffs] = useState<TableDiff[] | null>(null);
const [busy, setBusy] = useState(false);
const [error, setError] = useState<string | null>(null);
const [onlyDifferences, setOnlyDifferences] = useState(true);
const [picked, setPicked] = useState<Set<string>>(new Set());
const [expanded, setExpanded] = useState<Set<string>>(new Set());
const abort = useRef<AbortController | null>(null);
useEffect(() => {
if (!useDatabase.getState().loaded) void loadSources();
return () => abort.current?.abort();
}, []);
const ready = !!(source.id && source.schema && target.id && target.schema);
const same = source.id === target.id && source.schema === target.schema;
const targetDriver = sourceById(target.id)?.driver ?? "sqlite";
const compare = async () => {
abort.current?.abort();
const controller = (abort.current = new AbortController());
setBusy(true);
setError(null);
try {
const [s, t] = await Promise.all([
schemaSnapshot(source.id, source.schema, controller.signal),
schemaSnapshot(target.id, target.schema, controller.signal),
]);
if (controller.signal.aborted) return;
const result = diffSchemas(s, t);
setDiffs(result);
setPicked(differenceKeys(result));
// Changed tables open down to their differing items.
const open = result.filter((d) => d.state === "changed");
setExpanded(
new Set(open.flatMap((d) => [d.key, ...["Columns", "Indexes", "Foreign Keys"].map((g) => `${d.key}/${g}`)])),
);
} catch (e) {
if (!controller.signal.aborted) setError(e instanceof Error ? e.message : String(e));
} finally {
if (!controller.signal.aborted) setBusy(false);
}
};
const shown = useMemo(
() => (diffs ?? []).filter((d) => !onlyDifferences || d.state !== "same"),
[diffs, onlyDifferences],
);
const sql = useMemo(
() => (diffs ? migrationSql(targetDriver, target.schema, diffs, picked) : ""),
[diffs, picked, targetDriver, target.schema],
);
const differences = (diffs ?? []).filter((d) => d.state !== "same").length;
const children = (row: Row): Row[] | undefined => {
if (row.kind === "table") {
const d = row.diff;
const groups: Row[] = [];
const add = (label: string, items: ItemDiff<unknown>[]) => {
const visible = items.filter((i) => !onlyDifferences || i.state !== "same");
if (visible.length) groups.push({ kind: "group", key: `${d.key}/${label}`, label, items: visible, table: d });
};
add("Columns", d.columns);
add("Indexes", d.indexes);
add("Foreign Keys", d.foreignKeys);
return groups;
}
if (row.kind === "group") {
const what = row.label === "Columns" ? "column" : row.label === "Indexes" ? "index" : "foreignKey";
return row.items.map((diff) => ({ kind: "item", key: diff.key, diff, table: row.table, what }));
}
return undefined;
};
/** The keys a row's checkbox covers: a table covers its items too. */
const keysOf = (row: Row): string[] => {
if (row.kind === "item") return row.diff.state === "same" ? [] : [row.diff.key];
const d = row.kind === "table" ? row.diff : row.table;
const items = row.kind === "group" ? row.items : [...d.columns, ...d.indexes, ...d.foreignKeys];
const own = row.kind === "table" && d.state !== "same" ? [d.key] : [];
return [...own, ...items.filter((i) => i.state !== "same").map((i) => i.key)];
};
const toggle = (row: Row, on: boolean) =>
setPicked((p) => {
const next = new Set(p);
for (const k of keysOf(row)) {
if (on) next.add(k);
else next.delete(k);
}
return next;
});
const roots: Row[] = shown.map((diff) => ({ kind: "table", key: diff.key, diff }));
const copy = async () => {
await navigator.clipboard.writeText(sql);
notifications().notify({ level: "info", title: "Migration script copied", key: "db-compare" });
};
return (
<Dialog
open
onClose={closeDialog}
title="Compare Structure"
width={1040}
footerStart={<span className={styles.direction}>{ready && migrates(source, target)}</span>}
buttons={[
{ label: "Close", role: "cancel" },
{ label: "Copy", disabled: !sql, onClick: () => void copy() },
{
label: "Open in Console",
role: "default",
disabled: !sql,
onClick: () => {
closeDialog();
void openConsoleWith(target.id, sql);
},
},
]}
>
<div className={styles.body}>
<div className={styles.pickers}>
<SidePicker label="Source" side={source} onChange={setSource} />
<Icon name="arrow-right" size={14} className={styles.arrow} />
<SidePicker label="Target" side={target} onChange={setTarget} />
<Button size="small" variant="primary" disabled={!ready || same || busy} onClick={() => void compare()}>
<T>Compare</T>
</Button>
{busy && <Spinner size={14} />}
</div>
<div className={styles.toolbar}>
<Checkbox checked={onlyDifferences} onChange={setOnlyDifferences} label="Show only differences" />
<span className={styles.spacer} />
{diffs && <span className={styles.count}>{tx`${differences} of ${diffs.length} tables differ`}</span>}
</div>
<div className={styles.panes}>
<div className={styles.tree}>
{error ? (
<EmptyState title="Cannot compare">{error}</EmptyState>
) : !diffs ? (
<EmptyState
title={busy ? "Reading the schemas…" : "Pick a source and a target schema, then Compare"}
icon="diff-side-by-side"
/>
) : (
<Tree<Row>
roots={roots}
getKey={(r) => r.key}
getLabel={(r) => (r.kind === "table" ? r.diff.name : r.kind === "group" ? r.label : r.diff.name)}
getChildren={children}
isExpandable={(r) => r.kind !== "item"}
expanded={expanded}
onExpandedChange={(next) => setExpanded(next)}
aria-label={tx("Differences")}
empty={<EmptyState title="The schemas have the same structure" />}
renderNode={(r) => {
const keys = keysOf(r);
const on = keys.filter((k) => picked.has(k)).length;
const state = r.kind === "group" ? null : r.diff.state;
return (
<span className={styles.row}>
{keys.length > 0 && (
<Checkbox
checked={on === keys.length}
indeterminate={on > 0 && on < keys.length}
onChange={(v) => toggle(r, v)}
aria-label={includeLabel(r)}
/>
)}
{state && <StateIcon state={state} />}
<Icon
name={
r.kind === "table"
? "db-table"
: r.kind === "group"
? "db-folder"
: r.what === "column"
? "db-column"
: r.what === "index"
? "db-index"
: "db-foreign-key"
}
size={14}
/>
<span className={styles.name}>
{r.kind === "table" ? r.diff.name : r.kind === "group" ? tx(r.label) : r.diff.name}
</span>
{r.kind === "item" && <span className={styles.detail}>{itemDetail(r)}</span>}
</span>
);
}}
/>
)}
</div>
<CodePreview sql className={styles.preview} aria-label="Migration script" text={sql} />
</div>
</div>
</Dialog>
);
}
+6 -8
Переглянути файл
@@ -57,7 +57,7 @@ import {
type SqlCandidate,
type SqlCatalog,
} from "./sql/complete";
import { WHOLE_FILE, sqlSupport, type SqlText } from "./sqlSupport";
import { sqlSupport } from "./sqlSupport";
import { snowflakeLanguage } from "./sql/snowflakeHighlight";
import {
bindConsole,
@@ -729,7 +729,7 @@ function docNode(text: string): Node {
return pre;
}
function applyCandidate(c: SqlCandidate, driver: DbDriver, sql: SqlText) {
function applyCandidate(c: SqlCandidate, driver: DbDriver) {
return (view: EditorView, completion: Completion, from: number, to: number) => {
// A selected template placeholder is replaced, as CodeMirror's own string completions do.
const sel = view.state.selection.main;
@@ -752,7 +752,7 @@ function applyCandidate(c: SqlCandidate, driver: DbDriver, sql: SqlText) {
}
const changes: Array<{ from: number; to?: number; insert: string }> = [{ from, to, insert: text }];
// Re-read the statement as it is now: the user may have typed on since the popup opened.
const a = analyze(sql.text(view.state), to, driver);
const a = analyze(view.state.doc.toString(), to, driver);
if (a.fromInsert !== null) {
const clause = ` ${a.lowerKeywords ? "from" : "FROM"} ${c.addFrom}`;
if (a.fromInsert <= to) changes[0]!.insert += clause;
@@ -853,10 +853,8 @@ async function loadQualified(id: string, qualifier: readonly string[]): Promise<
if (schema && !useDatabase.getState().tables[tablesKey(target, schema)]) await loadTables(target, schema);
}
/** SQL completion in `path`, where `sql` says the SQL is (the whole file, or a mapper's statements). */
export function completionSource(path: string, sql: SqlText = WHOLE_FILE): CompletionSource {
function completionSource(path: string): CompletionSource {
return async (ctx: CompletionContext): Promise<CompletionResult | null> => {
if (sql.at && !sql.at(ctx.state, ctx.pos)) return null;
const id = consoleSource(path);
const current = id ? databaseRequest(id) : projectRequest();
const source = sourceById(id);
@@ -869,7 +867,7 @@ export function completionSource(path: string, sql: SqlText = WHOLE_FILE): Compl
// A selected template placeholder (`alias`) is about to be replaced: analyze without it.
const sel = ctx.state.selection.main;
const placeholder = !sel.empty && (ctx.pos === sel.from || ctx.pos === sel.to);
const doc = sql.text(ctx.state);
const doc = ctx.state.doc.toString();
const analysis = placeholder
? analyze(doc.slice(0, sel.from) + doc.slice(sel.to), sel.from, driver)
: analyze(doc, ctx.pos, driver);
@@ -897,7 +895,7 @@ export function completionSource(path: string, sql: SqlText = WHOLE_FILE): Compl
type: c.kind === "keyword" ? "keyword" : c.kind,
boost: Math.max(-99, Math.min(99, c.boost)),
info: c.doc ? () => docNode(c.doc!) : undefined,
apply: applyCandidate(c, driver, sql),
apply: applyCandidate(c, driver),
})),
validFor: /^[\p{L}\p{N}_$]*$/u,
};
-8
Переглянути файл
@@ -124,14 +124,6 @@ export function activate(): () => void {
() => import("./console").then((m) => m.consoleExtension),
),
}),
registerEditorContribution({
id: "database.mybatis",
order: 58,
extensions: lazyEditorExtension(
(ctx) => /\.xml$/i.test(ctx.path) && !ctx.virtual,
() => import("./mybatis").then((m) => m.mapperExtension),
),
}),
// A reopened project starts with a fresh backend: forget the old one's state.
useProject.subscribe((s, prev) => {
if (s.project?.root === prev.project?.root) return;
-112
Переглянути файл
@@ -1,112 +0,0 @@
import { CompletionContext, type CompletionResult, type CompletionSource } from "@codemirror/autocomplete";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { CONTRIBUTED_HOVER, type ContributedHover } from "@/editor/api";
import { useProject } from "@/platform/project";
import { mapperExtension } from "./mybatis";
import { useDatabase } from "./store";
const published = vi.hoisted(() => new Map<string, Array<{ message: string }>>());
vi.mock("@/editor/lsp/diagnostics", () => ({
setFileDiagnostics: (path: string, _source: string, items: Array<{ message: string }>) => published.set(path, items),
}));
const PATH = "/p/src/main/resources/mapper/UserMapper.xml";
const DOC = `<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.UserMapper">
<select id="find">
select id, nam from users where id = #{id}
</select>
<select id="other">select * from orders</select>
</mapper>
`;
let view: EditorView | null = null;
beforeEach(() => {
vi.useFakeTimers();
published.clear();
useProject.setState({
project: { name: "p", root: "/p", trusted: true } as never,
settings: {
database: { resolutionScopes: [{ path: "src/main/resources/mapper", dataSource: "pg", schema: "" }] },
} as never,
});
const column = (name: string) => ({
name,
dataType: "text",
nullable: true,
primaryKey: name === "id",
hasDefault: false,
});
useDatabase.setState({
loaded: true,
sources: [
{ id: "pg", name: "Local", driver: "postgres" },
{ id: "other", name: "Other", driver: "postgres" },
],
consoles: {},
consoleSchemas: {},
completion: {
pg: {
defaultSchema: "public",
tables: [{ schema: "public", name: "users", kind: "table", columns: [column("id"), column("name")] }],
foreignKeys: [],
},
},
});
});
afterEach(() => {
view?.destroy();
view = null;
vi.useRealTimers();
});
function open(doc: string) {
view = new EditorView({
parent: document.body,
state: EditorState.create({ doc, extensions: mapperExtension({ path: PATH, language: "xml" } as never) }),
});
return view;
}
function completionAt(state: EditorState, pos: number): Promise<CompletionResult | null> {
const sources = state.languageDataAt<CompletionSource>("openideaCompletion", pos);
return Promise.resolve(sources[0]!(new CompletionContext(state, pos, true)));
}
describe("SQL in MyBatis mappers", () => {
it("reports unresolved names of the statements against the scope's data source", () => {
open(DOC);
vi.advanceTimersByTime(1000);
const messages = (published.get(PATH) ?? []).map((d) => d.message);
expect(messages.some((m) => /nam\b/.test(m))).toBe(true);
expect(messages.some((m) => /orders/.test(m))).toBe(true);
expect(messages.some((m) => /users|\bid\b/.test(m))).toBe(false);
});
it("documents tables in the statements and nothing in the XML around them", () => {
const v = open(DOC);
const hover = v.state.languageDataAt<ContributedHover>(CONTRIBUTED_HOVER, 0)[0]!;
expect(hover(v.state, DOC.indexOf("users") + 2)?.markdown).toMatch(/users/);
expect(hover(v.state, DOC.indexOf("namespace") + 2)).toBeNull();
});
it("completes columns inside a statement only", async () => {
const doc = DOC.replace("select id, nam from users", "select n from users");
const v = open(doc);
const result = await completionAt(v.state, doc.indexOf("select n") + "select n".length);
expect(result?.options.map((o) => o.label)).toContain("name");
expect(await completionAt(v.state, doc.indexOf("namespace") + 4)).toBeNull();
});
it("leaves other XML files alone", () => {
const v = open("<beans><select>not sql</select></beans>");
vi.advanceTimersByTime(1000);
expect(published.get(PATH) ?? []).toEqual([]);
expect(v.dom.querySelectorAll("[class*=ͼ]").length).toBe(0);
});
});
-123
Переглянути файл
@@ -1,123 +0,0 @@
/**
* SQL in MyBatis mapper XML: the statements of `<select>`, `<insert>`, `<update>`, `<delete>`
* and `<sql>` are highlighted as SQL and get the SQL file's tools — completion, inspections,
* Go to Declaration and Quick Documentation — against the file's data source (its SQL
* resolution scope, or the project's only data source). See `sql/mapper` for what is SQL.
*/
import { MSSQL, MySQL, PLSQL, PostgreSQL, SQLite, StandardSQL, type SQLDialect } from "@codemirror/lang-sql";
import { highlightingFor } from "@codemirror/language";
import { EditorState, RangeSetBuilder, StateEffect, type Extension, type Text } from "@codemirror/state";
import { Decoration, ViewPlugin, type DecorationSet, type EditorView, type ViewUpdate } from "@codemirror/view";
import { highlightTree } from "@lezer/highlight";
import type { EditorDocContext } from "@/editor/api";
import type { DbDriver } from "@/platform/ipc";
import { completionSource } from "./console";
import { inMapperSql, isMapper, mapperSql, type MapperSql } from "./sql/mapper";
import { sqlSupport, type SqlText } from "./sqlSupport";
import { consoleSource, sourceById, useDatabase } from "./store";
const cache = new WeakMap<Text, MapperSql | null>();
/** The file's data source (and so its dialect) changed: colour the statements again. */
const recolour = StateEffect.define<null>();
/** The SQL of the mapper in `doc` (null when it is no mapper), computed once per document version. */
function mapperOf(doc: Text): MapperSql | null {
let sql = cache.get(doc);
if (sql === undefined) {
const text = doc.toString();
sql = isMapper(text) ? mapperSql(text) : null;
cache.set(doc, sql);
}
return sql;
}
const MAPPER_SQL: SqlText = {
text: (state) => mapperOf(state.doc)?.text ?? " ".repeat(state.doc.length),
at: (state, pos) => {
const sql = mapperOf(state.doc);
return !!sql && inMapperSql(sql, pos);
},
};
function dialectOf(driver: DbDriver): SQLDialect {
switch (driver) {
case "postgres":
return PostgreSQL;
case "mysql":
return MySQL;
case "sqlite":
return SQLite;
case "sqlServer":
return MSSQL;
case "oracle":
return PLSQL;
default:
return StandardSQL;
}
}
/** Syntax colours of the statements, in the bound data source's dialect, over the XML colours. */
function sqlColours(path: string): Extension {
const build = (view: EditorView): DecorationSet => {
const sql = mapperOf(view.state.doc);
if (!sql?.segments.length) return Decoration.none;
const driver = sourceById(consoleSource(path))?.driver ?? "sqlite";
const tree = dialectOf(driver).language.parser.parse(sql.text);
const builder = new RangeSetBuilder<Decoration>();
const marks = new Map<string, Decoration>();
const style = { style: (tags: Parameters<typeof highlightingFor>[1]) => highlightingFor(view.state, tags) };
let segment = 0;
for (const { from, to } of view.visibleRanges)
highlightTree(
tree,
style,
(a, b, cls) => {
// Only the file's own SQL text: the words standing in for tags are not shown.
while (segment < sql.segments.length && sql.segments[segment]!.to <= a) segment++;
for (let i = segment; i < sql.segments.length && sql.segments[i]!.from < b; i++) {
const s = sql.segments[i]!;
const f = Math.max(a, s.from);
const t = Math.min(b, s.to);
if (f >= t) continue;
let mark = marks.get(cls);
if (!mark) marks.set(cls, (mark = Decoration.mark({ class: cls })));
builder.add(f, t, mark);
}
},
from,
to,
);
return builder.finish();
};
return ViewPlugin.fromClass(
class {
decorations: DecorationSet;
private stop: () => void;
constructor(readonly view: EditorView) {
this.decorations = build(view);
// Another data source may mean another dialect.
this.stop = useDatabase.subscribe((s, prev) => {
if (s.sources !== prev.sources || s.consoles !== prev.consoles)
queueMicrotask(() => view.dispatch({ effects: recolour.of(null) }));
});
}
update(u: ViewUpdate) {
if (u.docChanged || u.viewportChanged || u.transactions.some((tr) => tr.effects.some((e) => e.is(recolour))))
this.decorations = build(u.view);
}
destroy() {
this.stop();
}
},
{ decorations: (v) => v.decorations },
);
}
/** The SQL support of MyBatis mapper `ctx.path` (inert in other XML files). */
export function mapperExtension(ctx: EditorDocContext): Extension {
return [
sqlColours(ctx.path),
EditorState.languageData.of(() => [{ openideaCompletion: completionSource(ctx.path, MAPPER_SQL) }]),
sqlSupport(ctx.path, MAPPER_SQL),
];
}
-90
Переглянути файл
@@ -1,90 +0,0 @@
import { describe, expect, it } from "vitest";
import type { DbColumnInfo } from "@/platform/ipc";
import { diffSchemas, differenceKeys, migrationSql, type TableSnapshot } from "./schemaCompare";
const col = (name: string, dataType: string, extra: Partial<DbColumnInfo> = {}): DbColumnInfo => ({
name,
dataType,
nullable: true,
default: null,
primaryKey: false,
...extra,
});
const users = (columns: DbColumnInfo[], indexes: TableSnapshot["indexes"] = []): TableSnapshot => ({
name: "users",
kind: "table",
columns,
indexes,
foreignKeys: [],
});
const SOURCE: TableSnapshot[] = [
users(
[
col("id", "int", { nullable: false, primaryKey: true }),
col("email", "varchar(255)", { nullable: false }),
col("age", "int", { default: "0" }),
],
[
{ name: "PRIMARY", unique: true, columns: ["id"] },
{ name: "users_email", unique: true, columns: ["email"] },
],
),
{
name: "orders",
kind: "table",
columns: [col("id", "int", { nullable: false, primaryKey: true }), col("user_id", "int")],
indexes: [
{ name: "PRIMARY", unique: true, columns: ["id"] },
{ name: "orders_user", unique: false, columns: ["user_id"] },
],
foreignKeys: [
{ schema: "app", table: "orders", columns: ["user_id"], refSchema: "app", refTable: "users", refColumns: ["id"] },
],
},
];
const TARGET: TableSnapshot[] = [
users(
[col("ID", "INT", { nullable: false, primaryKey: true }), col("email", "varchar(100)"), col("nickname", "text")],
[{ name: "PRIMARY", unique: true, columns: ["id"] }],
),
{ name: "legacy", kind: "table", columns: [col("x", "int")], indexes: [], foreignKeys: [] },
];
describe("Compare Structure", () => {
const diffs = diffSchemas(SOURCE, TARGET);
it("lists added, removed and changed tables with their column and index differences", () => {
expect(diffs.map((d) => `${d.name}:${d.state}`)).toEqual(["legacy:removed", "orders:added", "users:changed"]);
const u = diffs.find((d) => d.name === "users")!;
expect(u.columns.map((c) => `${c.name}:${c.state}:${c.changes.join("+")}`)).toEqual([
"id:same:",
"email:changed:type+nullable",
"age:added:",
"nickname:removed:",
]);
expect(u.indexes.map((i) => `${i.name}:${i.state}`)).toEqual(["PRIMARY:same", "users_email:added"]);
});
it("writes the migration of the selected differences for the target's dialect", () => {
const all = migrationSql("mysql", "app", diffs, differenceKeys(diffs));
expect(all).toBe(
[
"drop table app.legacy;",
"create table app.orders\n(\n id int not null,\n user_id int,\n primary key (id)\n);",
"alter table app.users change column email email varchar(255) not null;",
"alter table app.users add column age int default 0;",
"alter table app.users drop column nickname;",
"create index orders_user on app.orders (user_id);",
"alter table app.orders add foreign key (user_id) references app.users (id);",
"create unique index users_email on app.users (email);",
"",
].join("\n"),
);
// Only what is picked; identical items never produce SQL.
const some = migrationSql("postgres", "public", diffs, new Set(["c:users.age", "c:users.id", "t:legacy"]));
expect(some).toBe("drop table public.legacy;\nalter table public.users add column age int default 0;\n");
});
});
-234
Переглянути файл
@@ -1,234 +0,0 @@
/**
* Compare Structure (DataGrip's schema comparison): the differences between a source and a
* target schema — tables, columns, indexes and foreign keys — and the migration SQL that
* makes the chosen parts of the target match the source. Pure functions; nothing is run.
*/
import type { DbColumnInfo, DbDriver, DbForeignKey, DbIndexInfo, DbTableKind } from "@/platform/ipc";
import { alterTableSql, createTableSql, draftOf, ident, qualifiedName, type ColumnDraft } from "./objects";
export interface TableSnapshot {
name: string;
kind: DbTableKind;
columns: DbColumnInfo[];
indexes: DbIndexInfo[];
foreignKeys: DbForeignKey[];
}
/** `added`: only in the source (the migration creates it); `removed`: only in the target (it drops it). */
export type DiffState = "added" | "removed" | "changed" | "same";
export interface ItemDiff<T> {
/** Selection key, unique in the comparison. */
key: string;
name: string;
state: DiffState;
source?: T;
target?: T;
/** What differs, for a changed item: `type`, `nullable`, `default`, `primary key`, `unique`, `columns`, `references`. */
changes: string[];
}
export interface TableDiff extends ItemDiff<TableSnapshot> {
columns: ItemDiff<DbColumnInfo>[];
indexes: ItemDiff<DbIndexInfo>[];
foreignKeys: ItemDiff<DbForeignKey>[];
}
const norm = (s: string | null | undefined) => (s ?? "").trim().replace(/\s+/g, " ").toLowerCase();
/** Pairs items by name: exact first, then ignoring case. */
function pair<T>(
source: readonly T[],
target: readonly T[],
name: (t: T) => string,
): Array<[T | undefined, T | undefined]> {
const left = new Set(target);
const out: Array<[T | undefined, T | undefined]> = [];
for (const s of source) {
const n = name(s);
let t = [...left].find((x) => name(x) === n);
t ??= [...left].find((x) => name(x).toLowerCase() === n.toLowerCase());
if (t) left.delete(t);
out.push([s, t]);
}
for (const t of target) if (left.has(t)) out.push([undefined, t]);
return out;
}
function stateOf(source: unknown, target: unknown, changes: string[]): DiffState {
if (!target) return "added";
if (!source) return "removed";
return changes.length ? "changed" : "same";
}
function columnChanges(s: DbColumnInfo, t: DbColumnInfo): string[] {
const out: string[] = [];
if (norm(s.dataType) !== norm(t.dataType)) out.push("type");
if (s.nullable !== t.nullable) out.push("nullable");
if (norm(s.default) !== norm(t.default)) out.push("default");
if (s.primaryKey !== t.primaryKey) out.push("primary key");
return out;
}
const fkName = (k: DbForeignKey) => `(${k.columns.join(", ")}) → ${k.refTable}(${k.refColumns.join(", ")})`;
export function diffSchemas(source: readonly TableSnapshot[], target: readonly TableSnapshot[]): TableDiff[] {
return pair(source, target, (t) => t.name)
.map(([s, t]): TableDiff => {
const name = (s ?? t)!.name;
const columns = pair(s?.columns ?? [], t?.columns ?? [], (c) => c.name).map(([a, b]) => {
const changes = a && b ? columnChanges(a, b) : [];
return {
key: `c:${name}.${(a ?? b)!.name}`,
name: (a ?? b)!.name,
state: stateOf(a, b, changes),
source: a,
target: b,
changes,
};
});
const indexes = pair(s?.indexes ?? [], t?.indexes ?? [], (i) => i.name).map(([a, b]) => {
const changes: string[] = [];
if (a && b) {
if (a.unique !== b.unique) changes.push("unique");
if (norm(a.columns.join(",")) !== norm(b.columns.join(","))) changes.push("columns");
}
return {
key: `i:${name}.${(a ?? b)!.name}`,
name: (a ?? b)!.name,
state: stateOf(a, b, changes),
source: a,
target: b,
changes,
};
});
// Foreign keys have no comparable name across databases: they pair by what they link.
const foreignKeys = pair(s?.foreignKeys ?? [], t?.foreignKeys ?? [], (k) => norm(fkName(k))).map(([a, b]) => ({
key: `f:${name}.${fkName((a ?? b)!)}`,
name: fkName((a ?? b)!),
state: stateOf(a, b, []),
source: a,
target: b,
changes: [],
}));
const changes: string[] = [];
if (s && t && [...columns, ...indexes, ...foreignKeys].some((d) => d.state !== "same")) changes.push("content");
return {
key: `t:${name}`,
name,
state: stateOf(s, t, changes),
source: s,
target: t,
changes,
columns,
indexes,
foreignKeys,
};
})
.sort((a, b) => a.name.localeCompare(b.name));
}
/** Every key of a difference (not of identical items): the default selection. */
export function differenceKeys(diffs: readonly TableDiff[]): Set<string> {
const keys = new Set<string>();
for (const t of diffs) {
if (t.state === "same") continue;
keys.add(t.key);
for (const d of [...t.columns, ...t.indexes, ...t.foreignKeys]) if (d.state !== "same") keys.add(d.key);
}
return keys;
}
function createIndexSql(driver: DbDriver, schema: string, table: string, i: DbIndexInfo): string {
const cols = i.columns.map((c) => ident(driver, c)).join(", ");
return `create ${i.unique ? "unique " : ""}index ${ident(driver, i.name)} on ${qualifiedName(driver, schema, table)} (${cols});`;
}
function dropIndexSql(driver: DbDriver, schema: string, table: string, i: DbIndexInfo): string {
if (driver === "mysql" || driver === "sqlServer")
return `drop index ${ident(driver, i.name)} on ${qualifiedName(driver, schema, table)};`;
return `drop index ${qualifiedName(driver, schema, i.name)};`;
}
function addForeignKeySql(driver: DbDriver, schema: string, table: string, k: DbForeignKey): string {
const cols = (names: string[]) => names.map((c) => ident(driver, c)).join(", ");
return `alter table ${qualifiedName(driver, schema, table)} add foreign key (${cols(k.columns)}) references ${qualifiedName(driver, schema, k.refTable)} (${cols(k.refColumns)});`;
}
/**
* The statements making the selected differences of the target (`schema` on `driver`)
* match the source: drops of foreign keys and indexes first, then tables and columns,
* then new indexes and foreign keys. A dropped foreign key has no portable name: it is
* left as a comment to write by hand.
*/
export function migrationSql(
driver: DbDriver,
schema: string,
diffs: readonly TableDiff[],
selected: ReadonlySet<string>,
): string {
const first: string[] = [];
const tables: string[] = [];
const last: string[] = [];
for (const t of diffs) {
const pick = (d: ItemDiff<unknown>) => selected.has(d.key) && d.state !== "same";
if (t.state === "added") {
if (!selected.has(t.key) || !t.source) continue;
tables.push(
createTableSql(
driver,
schema,
t.name,
t.source.columns.map((c, i) => ({ ...draftOf(c, i), original: null })),
).trimEnd(),
);
// The primary key's own index comes with the table.
const key = t.source.columns.filter((c) => c.primaryKey).map((c) => norm(c.name));
const isKey = (i: DbIndexInfo) =>
i.unique && i.columns.length === key.length && i.columns.every((c) => key.includes(norm(c)));
for (const i of t.source.indexes) if (!isKey(i)) last.push(createIndexSql(driver, schema, t.name, i));
for (const k of t.source.foreignKeys) last.push(addForeignKeySql(driver, schema, t.name, k));
continue;
}
if (t.state === "removed") {
if (selected.has(t.key)) tables.push(`drop table ${qualifiedName(driver, schema, t.name)};`);
continue;
}
for (const k of t.foreignKeys)
if (pick(k) && k.state === "removed")
first.push(
`-- drop the foreign key ${k.name} of ${qualifiedName(driver, schema, t.name)} (constraint name differs per database)`,
);
for (const i of t.indexes)
if (pick(i) && (i.state === "removed" || i.state === "changed"))
first.push(dropIndexSql(driver, schema, t.name, i.target!));
const drafts: ColumnDraft[] = [];
t.columns.forEach((c, n) => {
if (!pick(c)) return;
if (c.state === "added") drafts.push({ ...draftOf(c.source!, n), original: null });
else if (c.state === "removed") drafts.push({ ...draftOf(c.target!, n), dropped: true });
else {
const s = c.source!;
drafts.push({ ...draftOf(c.target!, n), dataType: s.dataType, notNull: !s.nullable, default: s.default ?? "" });
}
});
if (drafts.length) tables.push(...alterTableSql(driver, schema, t.name, t.name, drafts));
// SQLite only adds and drops columns: a changed one is rebuilt by hand.
if (driver === "sqlite")
for (const c of t.columns)
if (pick(c) && c.state === "changed")
tables.push(
`-- SQLite cannot alter ${qualifiedName(driver, schema, t.name)}.${ident(driver, c.name)} (${c.changes.join(", ")}): rebuild the table`,
);
for (const c of t.columns)
if (pick(c) && c.changes.includes("primary key"))
last.push(`-- the primary key of ${qualifiedName(driver, schema, t.name)} changes at ${ident(driver, c.name)}`);
for (const i of t.indexes)
if (pick(i) && (i.state === "added" || i.state === "changed"))
last.push(createIndexSql(driver, schema, t.name, i.source!));
for (const k of t.foreignKeys)
if (pick(k) && k.state === "added") last.push(addForeignKeySql(driver, schema, t.name, k.source!));
}
const all = [...first, ...tables, ...last];
return all.length ? `${all.join("\n")}\n` : "";
}
-55
Переглянути файл
@@ -1,55 +0,0 @@
import { describe, expect, it } from "vitest";
import { inMapperSql, isMapper, mapperSql } from "./mapper";
const MAPPER = `<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.UserMapper">
<resultMap id="user" type="User"><id column="id" property="id"/></resultMap>
<select id="find" resultMap="user">
select id, name from users
<where>
<if test="name != null">and name = #{name}</if>
<if test="ids != null">and id in
<foreach collection="ids" item="i" open="(" separator="," close=")">#{i}</foreach>
</if>
and age &gt; 18
</where>
</select>
<insert id="add">
<selectKey keyProperty="id" resultType="int">select last_insert_id()</selectKey>
insert into users (name) values (#{name})
</insert>
<!-- <select id="old">select * from old</select> -->
<update id="rename"><![CDATA[update users set name = #{name} where age < 3]]></update>
<update id="touch">update users <set><if test="a">name = #{a},</if></set> where id = #{id}</update>
</mapper>`;
describe("MyBatis mapper SQL", () => {
it("recognises mapper files", () => {
expect(isMapper(MAPPER)).toBe(true);
expect(isMapper("<beans><bean id='a'/></beans>")).toBe(false);
});
it("keeps the statements' SQL at its offsets and blanks the rest", () => {
const { text } = mapperSql(MAPPER);
expect(text).toHaveLength(MAPPER.length);
expect(text.split("\n")).toHaveLength(MAPPER.split("\n").length);
const sql = text.replace(/\s+/g, " ").trim();
expect(sql).toBe(
"select id, name from users where name = ? and id in ( ? ) and age > 18 ; " +
"insert into users (name) values (? ) ; update users set name = ? where age < 3 ; " +
"update users set name = ? where id = ? ;",
);
const at = MAPPER.indexOf("users");
expect(text.slice(at, at + 5)).toBe("users");
});
it("knows which offsets are SQL", () => {
const sql = mapperSql(MAPPER);
expect(inMapperSql(sql, MAPPER.indexOf("from users") + 2)).toBe(true);
expect(inMapperSql(sql, MAPPER.indexOf("resultMap="))).toBe(false);
expect(inMapperSql(sql, MAPPER.indexOf('test="name'))).toBe(false);
expect(inMapperSql(sql, MAPPER.indexOf("last_insert_id"))).toBe(false);
expect(inMapperSql(sql, MAPPER.indexOf("from old"))).toBe(false);
});
});
-154
Переглянути файл
@@ -1,154 +0,0 @@
/**
* The SQL of a MyBatis mapper XML file, as one text the SQL tools read: everything but the
* SQL of `<select>` / `<insert>` / `<update>` / `<delete>` / `<sql>` is blanked out with
* spaces (line breaks kept), so offsets are the file's own. Parameters (`#{id}`, `${col}`)
* read as `?`, entities as their character, dynamic tags as nothing — except `<where>`,
* `<set>`, `<trim prefix>` and `<foreach open / close>`, which read as what they add — and
* each statement ends with a `;`.
*/
const STATEMENTS = new Set(["select", "insert", "update", "delete", "sql"]);
/** Their content is not part of the statement's SQL. */
const SKIPPED = new Set(["selectKey"]);
const ENTITIES: Record<string, string> = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'" };
export interface MapperSql {
/** The file's text with only SQL left (same length). */
text: string;
/** The SQL text taken from the file, as ranges of offsets: the positions the SQL tools apply to. */
segments: Array<{ from: number; to: number }>;
}
/** Whether `text` is a MyBatis (or iBatis) mapper. */
export function isMapper(text: string): boolean {
const head = text.slice(0, 4000);
return /<mapper[\s>]/.test(head) && /mybatis|ibatis|<mapper[^>]*\snamespace\s*=/i.test(head);
}
const TAG = /<!--[\s\S]*?(?:-->|$)|<!\[CDATA\[|\]\]>|<(\/?)([A-Za-z_][\w.:-]*)((?:[^>"']|"[^"]*"|'[^']*')*?)(\/?)>/g;
function attr(attrs: string, name: string): string | null {
const m = new RegExp(`(?:^|\\s)${name}\\s*=\\s*("([^"]*)"|'([^']*)')`).exec(attrs);
return m ? (m[2] ?? m[3] ?? "") : null;
}
export function mapperSql(doc: string): MapperSql {
const out = doc.replace(/[^\n]/g, " ").split("");
const segments: MapperSql["segments"] = [];
/** Writes `what` at `at`, as far as `room` characters allow. */
const put = (at: number, what: string, room: number) => {
if (what.length > room) return;
for (let i = 0; i < what.length; i++) out[at + i] = what[i]!;
};
const copy = (from: number, to: number) => {
if (to <= from) return;
let at = from;
const text = doc.slice(from, to);
// Parameters and entities inside the SQL text.
const special = /#\{[^}]*\}?|\$\{[^}]*\}?|&(lt|gt|amp|quot|apos);/g;
for (let m = special.exec(text); m; m = special.exec(text)) {
const start = from + m.index;
for (let i = at; i < start; i++) out[i] = doc[i]!;
if (m[1]) put(start, ENTITIES[m[1]]!, m[0].length);
else put(start, "?", m[0].length);
at = start + m[0].length;
}
for (let i = at; i < to; i++) out[i] = doc[i]!;
const last = segments.at(-1);
if (last && last.to === from) last.to = to;
else segments.push({ from, to });
};
/** Inside a statement: its depth of nested tags, the `close` text of open `<foreach>` / `<trim>`. */
let statement: { name: string; depth: number } | null = null;
const closes: Array<{ text: string | null; trailingComma: boolean }> = [];
/** Where `<where>` / `<trim prefixOverrides>` drop a leading AND / OR, `<set>` a trailing comma. */
const leading: number[] = [];
const trailing: number[] = [];
let skipping = 0;
let textFrom = 0;
TAG.lastIndex = 0;
for (let m = TAG.exec(doc); m; m = TAG.exec(doc)) {
const at = m.index;
const end = at + m[0].length;
if (statement && !skipping) copy(textFrom, at);
textFrom = end;
const [whole, closing, name, attrs = "", selfClosing] = m;
// CDATA content is SQL text as written, markup characters included.
if (whole === "<![CDATA[") {
const close = doc.indexOf("]]>", end);
const stop = close < 0 ? doc.length : close;
if (statement && !skipping) copy(end, stop);
textFrom = TAG.lastIndex = Math.min(doc.length, stop + 3);
continue;
}
// Comments (and a stray `]]>`) are blank.
if (!name) continue;
if (!statement) {
if (!closing && !selfClosing && STATEMENTS.has(name)) statement = { name, depth: 0 };
continue;
}
if (closing) {
if (statement.depth === 0 && name === statement.name) {
put(at, ";", whole.length);
statement = null;
closes.length = 0;
skipping = 0;
continue;
}
statement.depth = Math.max(0, statement.depth - 1);
if (skipping) {
skipping--;
continue;
}
const close = closes.pop();
if (close?.trailingComma) trailing.push(at);
if (close?.text) put(at, ` ${close.text} `, whole.length);
continue;
}
if (selfClosing) continue;
statement.depth++;
if (skipping || SKIPPED.has(name)) {
skipping++;
continue;
}
let open: string | null = null;
let close: string | null = null;
let trailingComma = false;
if (name === "where") {
open = "where";
leading.push(end);
} else if (name === "set") {
open = "set";
trailingComma = true;
} else if (name === "trim") {
open = attr(attrs, "prefix");
close = attr(attrs, "suffix");
if (/\b(and|or)\b/i.test(attr(attrs, "prefixOverrides") ?? "")) leading.push(end);
trailingComma = (attr(attrs, "suffixOverrides") ?? "").includes(",");
} else if (name === "foreach") {
open = attr(attrs, "open");
close = attr(attrs, "close");
}
if (open) put(at, ` ${open} `, whole.length);
closes.push({ text: close, trailingComma });
}
if (statement && !skipping) copy(textFrom, doc.length);
for (const from of leading) {
let i = from;
while (i < out.length && /\s/.test(out[i]!)) i++;
const word = /^(and|or)\b/i.exec(out.slice(i, i + 4).join(""));
if (word) for (let k = 0; k < word[0].length; k++) out[i + k] = " ";
}
for (const before of trailing) {
let i = before - 1;
while (i >= 0 && /\s/.test(out[i]!)) i--;
if (out[i] === ",") out[i] = " ";
}
return { text: out.join(""), segments };
}
/** Whether offset `pos` is in (or right after) SQL text of the mapper. */
export function inMapperSql(sql: MapperSql, pos: number): boolean {
return sql.segments.some((s) => pos >= s.from && pos <= s.to);
}
+14 -41
Переглянути файл
@@ -20,7 +20,6 @@ import { offsetToPos } from "@/editor/lsp/positions";
import type { DbCompletion, DbCompletionTable, DbDriver } from "@/platform/ipc";
import { formatSql } from "./sql/format";
import { SqlResolver, type SqlSymbol } from "./sql/resolve";
import { useProject } from "@/platform/project";
import { consoleSchema, consoleSource, revealInTree, sourceById, useDatabase } from "./store";
/** Producer id of the console's diagnostics (Problems view, hover). */
@@ -39,29 +38,18 @@ function sourceOf(path: string): { id: string | null; driver: DbDriver; model: D
};
}
/**
* Where the SQL of a file is: its text as the SQL tools read it (the file's offsets), and
* whether an offset is in SQL. A SQL file is SQL throughout; a MyBatis mapper only in its statements.
*/
export interface SqlText {
text(state: EditorState): string;
at?(state: EditorState, pos: number): boolean;
}
export const WHOLE_FILE: SqlText = { text: (state) => state.doc.toString() };
function resolver(path: string, state: EditorState, sql: SqlText): SqlResolver {
function resolver(path: string, state: EditorState): SqlResolver {
const { driver, model } = sourceOf(path);
return new SqlResolver(sql.text(state), driver, model);
return new SqlResolver(state.doc.toString(), driver, model);
}
/** Unresolved tables / columns / aliases as error diagnostics, re-checked after edits and schema loads. */
function inspections(path: string, sql: SqlText): Extension {
function inspections(path: string): Extension {
return ViewPlugin.define((view) => {
let timer: ReturnType<typeof setTimeout> | undefined;
const run = () => {
const doc = view.state.doc;
const problems = sourceOf(path).model ? resolver(path, view.state, sql).problems() : [];
const problems = sourceOf(path).model ? resolver(path, view.state).problems() : [];
setFileDiagnostics(
path,
INSPECTIONS,
@@ -81,18 +69,9 @@ function inspections(path: string, sql: SqlText): Extension {
schedule();
// The schema model arrives (or the console is bound to another source / schema) after the editor opens.
const unsubscribe = useDatabase.subscribe((s, prev) => {
if (
s.completion !== prev.completion ||
s.consoles !== prev.consoles ||
s.consoleSchemas !== prev.consoleSchemas ||
s.sources !== prev.sources
)
if (s.completion !== prev.completion || s.consoles !== prev.consoles || s.consoleSchemas !== prev.consoleSchemas)
schedule();
});
// SQL resolution scopes can move the file to another data source.
const unsubscribeSettings = useProject.subscribe((s, prev) => {
if (s.settings !== prev.settings) schedule();
});
return {
update: (u) => {
if (u.docChanged) schedule();
@@ -100,20 +79,16 @@ function inspections(path: string, sql: SqlText): Extension {
destroy: () => {
clearTimeout(timer);
unsubscribe();
unsubscribeSettings();
setFileDiagnostics(path, INSPECTIONS, []);
},
};
});
}
function definition(path: string, sql: SqlText): ContributedDefinition {
function definition(path: string): ContributedDefinition {
return (view, pos) => {
if (sql.at && !sql.at(view.state, pos)) return false;
const r = resolver(path, view.state, sql).resolveAt(pos);
const r = resolver(path, view.state).resolveAt(pos);
const sym = r?.symbol;
// Outside SQL names, other providers (the XML language server) may know the place.
if (!sym && sql.at) return false;
const id = consoleSource(path);
const reveal = (t: DbCompletionTable, column?: string) => {
if (id) void revealInTree(id, t.schema, t.name, t.kind, column);
@@ -197,10 +172,9 @@ function symbolDoc(sym: SqlSymbol, model: DbCompletion | null): string | null {
}
}
function hover(path: string, sql: SqlText): ContributedHover {
function hover(path: string): ContributedHover {
return (state, pos) => {
if (sql.at && !sql.at(state, pos)) return null;
const r = resolver(path, state, sql).resolveAt(pos);
const r = resolver(path, state).resolveAt(pos);
const markdown = r?.symbol ? symbolDoc(r.symbol, sourceOf(path).model) : null;
return r && markdown ? { from: r.from, to: r.to, markdown } : null;
};
@@ -210,12 +184,11 @@ function formatter(path: string): ContributedFormatter {
return (state, range) => formatSql(state.doc.toString(), sourceOf(path).driver, range);
}
/** Inspections, navigation and documentation for the SQL of `path` (and Reformat Code for SQL files). */
export function sqlSupport(path: string, sql: SqlText = WHOLE_FILE): Extension {
export function sqlSupport(path: string): Extension {
const data = {
[CONTRIBUTED_DEFINITION]: definition(path, sql),
[CONTRIBUTED_HOVER]: hover(path, sql),
...(sql === WHOLE_FILE ? { [CONTRIBUTED_FORMAT]: formatter(path) } : {}),
[CONTRIBUTED_DEFINITION]: definition(path),
[CONTRIBUTED_HOVER]: hover(path),
[CONTRIBUTED_FORMAT]: formatter(path),
};
return [inspections(path, sql), EditorState.languageData.of(() => [data])];
return [inspections(path), EditorState.languageData.of(() => [data])];
}
+1 -23
Переглянути файл
@@ -56,7 +56,6 @@ import { formatted } from "./sql/format";
import { bindParams, findParams } from "./sql/params";
import { isReadOnlyQuery } from "./sql/readOnly";
import { pageFetch } from "./resultView";
import type { TableSnapshot } from "./schemaCompare";
import { resolutionScopeOf, resolutionScopesOf, type SqlResolutionScope } from "./resolutionScopes";
import { databaseRequest, invalidateDatabaseRequests, projectRequest } from "./requests";
import { tx } from "@/platform/i18n";
@@ -144,9 +143,7 @@ export type DialogState =
/** Browse Query History of target `id`; Paste goes to console `path`. */
| { kind: "history"; id: string; path: string | null }
/** Import Data from File into a table. */
| { kind: "import"; id: string; schema: string; table: string }
/** Compare Structure: `source` starts as the schema the action was invoked on. */
| { kind: "compareSchemas"; source: { id: string; schema: string } | null };
| { kind: "import"; id: string; schema: string; table: string };
/** The schemas and tables of a data source's databases, as far as introspection has read them. */
export interface SourceCatalog {
@@ -712,25 +709,6 @@ export async function loadTables(id: string, schema: string): Promise<void> {
}
}
/** The tables of `schema` on target `id` with their columns, indexes and foreign keys (Compare Structure). */
export async function schemaSnapshot(id: string, schema: string, signal?: AbortSignal): Promise<TableSnapshot[]> {
const tables = (await withConnection(id, () => call(commands.dbTables(id, schema)))).filter(
(t) => t.kind === "table",
);
const out: TableSnapshot[] = [];
let next = 0;
const worker = async () => {
while (next < tables.length) {
if (signal?.aborted) return;
const t = tables[next++]!;
const details = await call(commands.dbTableDetails(id, schema, t.name));
out.push({ name: t.name, kind: t.kind, ...details });
}
};
await Promise.all(Array.from({ length: Math.min(4, tables.length) }, worker));
return out;
}
export async function loadDetails(id: string, schema: string, table: string): Promise<void> {
const key = detailsKey(id, schema, table);
const current = metadataRequest(id, "details", key);
-16
Переглянути файл
@@ -389,22 +389,6 @@ export function registerDatabaseTreeActions(): () => void {
if (schema !== null) openDialog({ kind: "modifyTable", id, schema, table: null });
},
}),
tree({
id: "db.compareSchemas",
title: "Compare Structure…",
description: "Compare the tables of two schemas and write the migration SQL from one to the other",
icon: "diff-side-by-side",
keywords: ["schema compare", "diff", "migration", "compare schemas", "structure"],
run: ({ arg }) => {
const n = nodeFrom(arg);
const id = n && nodeTarget(n);
const schema = n && "schema" in n && typeof n.schema === "string" ? n.schema : null;
openDialog({
kind: "compareSchemas",
source: id ? { id, schema: schema ?? (driverOf(id) === "sqlite" ? "main" : "") } : null,
});
},
}),
tree({
id: "db.newColumn",
title: "Column",
-2
Переглянути файл
@@ -117,7 +117,6 @@ export function nodeMenu(n: DbNode | null): MenuItem[] {
navigation(),
sep,
sqlScripts(n, false),
act("db.compareSchemas", n),
sep,
act("db.drop", n, { label: "Remove Data Source…" }),
];
@@ -143,7 +142,6 @@ export function nodeMenu(n: DbNode | null): MenuItem[] {
navigation(),
sep,
sqlScripts(n, false),
...(n.kind === "schema" ? [act("db.compareSchemas", n)] : []),
...(n.kind === "schema" ? [sep, drop] : []),
];
case "table":
+1
Переглянути файл
@@ -83,6 +83,7 @@ import { pausedLineTargets, startInlineSmartStep } from "./editor/smartStep";
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;
+3
Переглянути файл
@@ -56,6 +56,9 @@
.excluded {
color: var(--vcs-ignored);
}
.excludedRow {
background: color-mix(in srgb, var(--vcs-ignored) 14%, transparent);
}
.error {
text-decoration-line: underline;
text-decoration-style: wavy;
+5 -4
Переглянути файл
@@ -436,8 +436,6 @@ interface DragState {
}
const DRAG_THRESHOLD = 4;
/** IDEA's "excluded" look: excluded folders and what is under them get a muted band. */
const EXCLUDED_TINT = "var(--vcs-ignored)";
/** Folder under a viewport point inside `container` (a file row resolves to its folder). */
function folderAt(container: HTMLElement | null, x: number, y: number): { key: string; path: string } | null {
@@ -875,8 +873,11 @@ export function ProjectView() {
isExpandable={isExpandable}
loadChildren={loadChildren}
renderNode={renderNode}
rowTint={(n) =>
n.excluded ? EXCLUDED_TINT : n.group || n.placeholder ? undefined : fileColors?.(n.path, n.dir)
rowClassName={(n) => (n.excluded ? styles.excludedRow : undefined)}
rowTint={
fileColors
? (n) => (n.excluded || n.group || n.placeholder ? undefined : fileColors(n.path, n.dir))
: undefined
}
expanded={expanded}
onExpandedChange={onExpandedChange}
+1 -4
Переглянути файл
@@ -5,7 +5,6 @@ import { call, commands, onIdeEvent, type TrustDecisions, type TrustStatus } fro
import { dirname, useProject } from "@/platform/project";
import { initializeRemoteTrustMigration, isRemoteRoot } from "@/platform/remote";
import { provideProjectTrustPrompt, type ProjectTrustScope } from "@/platform/projectTrust";
import { askOverSplash } from "@/platform/splash";
import { invokeLocal } from "@/platform/tauriCore";
import { registerOverlay, registerSettingsPage, registerWorkbenchBanner } from "@/workbench/contributions";
import { Button, Checkbox, Dialog, T } from "@/ui";
@@ -210,7 +209,7 @@ async function decide(trusted: boolean) {
function promptForTrust(status: TrustStatus, scope: ProjectTrustScope): Promise<boolean> {
usePrompt.getState().finish?.(false);
const answer = new Promise<boolean>((resolve) =>
return new Promise<boolean>((resolve) =>
usePrompt.setState({
path: status.root,
scope,
@@ -221,8 +220,6 @@ function promptForTrust(status: TrustStatus, scope: ProjectTrustScope): Promise<
},
}),
);
askOverSplash(answer);
return answer;
}
async function trustProject() {
-17
Переглянути файл
@@ -224,20 +224,3 @@ it.each([false, true])("recovers an attached member whose trust is lost (decided
await act(async () => {});
expect(decide).toHaveBeenCalledWith("/other", true, false);
});
it("asks over the splash of a window launched for an untrusted project, not over its Welcome screen", async () => {
const splash = document.createElement("div");
splash.id = "splash";
document.body.append(splash);
try {
render(<OverlayHost />);
vi.mocked(invokeLocal).mockResolvedValue({ root: "/launched", trusted: false, decided: false });
const opening = confirmProjectTrust("/launched", "local").catch(() => "cancelled");
await screen.findByRole("dialog");
expect(splash.classList.contains("splash-under-dialogs")).toBe(true);
fireEvent.click(screen.getByRole("button", { name: "Don't Open" }));
expect(await opening).toBe("cancelled");
} finally {
splash.remove();
}
});
-94
Переглянути файл
@@ -1,94 +0,0 @@
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { act, fireEvent, render, screen } from "@testing-library/react";
import type { Sdk, Settings } from "@/platform/ipc";
const open = vi.fn();
const JDK: Sdk = {
path: "/opt/jdks/acme-17/Contents/Home",
name: "Acme 17.0.9",
version: "17.0.9",
source: "system",
home: "/opt/jdks/acme-17/Contents/Home",
extra: null,
};
vi.mock("@/platform/dialog", () => ({ open: (...args: unknown[]) => open(...args) }));
vi.mock("@/platform/ipc", async (importOriginal) => {
const real = await importOriginal<typeof import("@/platform/ipc")>();
return {
...real,
isTauri: () => true,
commands: {
...real.commands,
sdkDetect: vi.fn(async () => ({ status: "ok", data: [] })),
sdkJdkAt: vi.fn(async (path: string) => ({
status: "ok",
data: path.startsWith("/opt/jdks/acme-17") ? JDK : null,
})),
settingsSet: vi.fn(async () => ({ status: "ok", data: {} })),
settingsGet: vi.fn(async () => ({})),
settingsGetGlobal: vi.fn(async () => ({})),
},
};
});
import { useProject } from "@/platform/project";
import { useContextMenuStore } from "@/ui/Menu";
import { DEFAULT_SETTINGS } from "../model/schema";
import { openProjectStructure, stagedValue, useSettingsDialog } from "../model/staging";
import { ProjectStructureDialog } from "../languages/ProjectStructurePage";
import { useSdks } from "../languages/api";
function addMenuItem(label: string) {
fireEvent.click(screen.getByRole("button", { name: "Add SDK" }));
const item = useContextMenuStore.getState().menu?.items.find((i) => "label" in i && i.label === label) as
| { run?: () => void }
| undefined;
expect(item?.run).toBeDefined();
item!.run!();
}
const added = () => stagedValue(useSettingsDialog.getState(), "global", "languages.java.addedJdks");
beforeEach(() => {
open.mockReset();
useSdks.setState({ byKind: {}, loading: {}, errors: {} });
useProject.setState({
settings: structuredClone(DEFAULT_SETTINGS) as Settings,
project: { name: "demo", root: "/project" } as never,
});
render(<ProjectStructureDialog />);
act(() => openProjectStructure("sdks"));
});
afterEach(() => {
act(() => useSettingsDialog.setState({ projectStructureOpen: false }));
useProject.setState({ project: null, settings: null });
});
describe("SDKs › Add JDK from Disk…", () => {
it("adds the picked JDK home to the list and the global settings, and removes it again", async () => {
open.mockResolvedValue("/opt/jdks/acme-17");
await act(async () => addMenuItem("Add JDK from Disk…"));
expect(open).toHaveBeenCalledWith(expect.objectContaining({ directory: true }));
expect(screen.getAllByText("Acme 17.0.9").length).toBeGreaterThan(0);
expect(added()).toEqual([JDK.path]);
fireEvent.click(screen.getByRole("button", { name: "Remove SDK" }));
expect(screen.queryByText("Acme 17.0.9")).not.toBeInTheDocument();
expect(added()).toEqual([]);
});
it("refuses a folder that is no JDK home", async () => {
open.mockResolvedValue("/tmp/not-a-jdk");
await act(async () => addMenuItem("Add JDK from Disk…"));
expect(screen.getByRole("alert")).toHaveTextContent("The selected directory is not a valid home for JDK");
expect(added() ?? []).toEqual([]);
});
it("keeps detected SDKs from being removed", async () => {
await act(async () => useSdks.setState({ byKind: { jdk: [JDK] } }));
fireEvent.click(screen.getByRole("option", { name: /Acme 17\.0\.9/ }));
expect(screen.getByRole("button", { name: "Remove SDK" })).toBeDisabled();
});
});
+1 -5
Переглянути файл
@@ -1,6 +1,6 @@
import { describe, expect, it } from "vitest";
import { normalizeBinding } from "@/platform/keymap";
import { fromSwingStroke, parseIdeaKeymap } from "./ideaKeymap";
import { fromSwingStroke, parseIdeaKeymap } from "../keymap/ideaKeymapImport";
describe("IntelliJ IDEA keymap import", () => {
it("converts Swing keystrokes", () => {
@@ -8,10 +8,6 @@ describe("IntelliJ IDEA keymap import", () => {
expect(fromSwingStroke("ctrl pressed OPEN_BRACKET")).toBe("Ctrl+[");
expect(fromSwingStroke("F12")).toBe("F12");
expect(fromSwingStroke("alt BACK_SPACE")).toBe("Alt+Backspace");
// As IDEA saves a user's keymap.
expect(fromSwingStroke("ctrl right")).toBe("Ctrl+Right");
expect(fromSwingStroke("shift ctrl alt s")).toBe("Shift+Ctrl+Alt+S");
expect(fromSwingStroke("meta back_slash")).toBe("Meta+\\");
expect(fromSwingStroke("meta NUMPAD5")).toBeNull();
expect(fromSwingStroke("hyper A")).toBeNull();
});
+1 -1
Переглянути файл
@@ -53,7 +53,7 @@ import {
} from "./model";
import { groupIcon, groupPath, groupRank } from "./groups";
import { KeymapNameDialog } from "./KeymapDialogs";
import { parseIdeaKeymap } from "@/platform/ideaKeymap";
import { parseIdeaKeymap } from "./ideaKeymapImport";
import { RecordShortcutDialog } from "./RecordShortcutDialog";
import { StrokeRecorder } from "./StrokeRecorder";
import styles from "./Keymap.module.css";
+4 -28
Переглянути файл
@@ -4,16 +4,8 @@
* parent; each listed action's shortcuts replace the parent's.
*/
import { IDEA_ACTIONS } from "@/platform/ideaActions";
import type { CustomKeymap } from "@/bindings";
import {
customKeymapId,
defaultPreset,
isValidBinding,
normalizeBinding,
PRESET_TITLES,
withBindings,
type Keymap,
} from "@/platform/keymap";
import { defaultPreset, isValidBinding, normalizeBinding, type Keymap } from "@/platform/keymap";
import { withBindings } from "./model";
export interface ImportedIdeaKeymap {
name: string;
@@ -75,16 +67,13 @@ const SWING_KEYS: Record<string, string> = {
const SWING_MODS: Record<string, string> = { shift: "Shift", ctrl: "Ctrl", control: "Ctrl", alt: "Alt", meta: "Meta" };
/**
* `"shift meta O"` / `"ctrl pressed OPEN_BRACKET"` → `"Meta+Shift+O"`, or null when not expressible.
* Bundled keymaps name keys in upper case; the keymaps IDEA saves for the user are all lower case (`"ctrl right"`).
*/
/** `"shift meta O"` / `"ctrl pressed OPEN_BRACKET"` → `"Meta+Shift+O"`, or null when not expressible. */
export function fromSwingStroke(stroke: string): string | null {
const words = stroke
.trim()
.split(/\s+/)
.filter((w) => !/^(pressed|released|typed)$/i.test(w));
const key = words.pop()?.toUpperCase();
const key = words.pop();
if (!key || words.some((w) => !SWING_MODS[w.toLowerCase()])) return null;
const name = /^([A-Z0-9]|F\d{1,2})$/.test(key) ? key : SWING_KEYS[key];
return name ? [...words.map((w) => SWING_MODS[w.toLowerCase()]), name].join("+") : null;
@@ -145,16 +134,3 @@ export function parseIdeaKeymap(xml: string): ImportedIdeaKeymap {
skippedShortcuts,
};
}
/**
* Adds a parsed keymap to the user keymaps under its own name, replacing an
* earlier import of the same name (a name a bundled keymap has gets a suffix).
*/
export function addIdeaKeymap(
customs: Record<string, CustomKeymap>,
parsed: ImportedIdeaKeymap,
): { id: string; customs: Record<string, CustomKeymap> } {
const name = Object.values(PRESET_TITLES).includes(parsed.name) ? `${parsed.name} (JetBrains)` : parsed.name;
const id = Object.keys(customs).find((k) => customs[k]?.name === name) ?? customKeymapId(name, customs);
return { id, customs: { ...customs, [id]: { name, parent: parsed.parent, overrides: parsed.overrides } } };
}
+39 -13
Переглянути файл
@@ -5,19 +5,23 @@
*/
import type { Action } from "@/platform/actions";
import { evaluateWhen, type ContextKeys } from "@/platform/context";
import {
customKeymapId,
defaultPreset,
normalizeBinding,
presetBindings,
PRESET_TITLES,
PRESETS,
withBindings,
type Keymap,
type KeymapDraft,
} from "@/platform/keymap";
import { defaultPreset, normalizeBinding, PRESET_TITLES, PRESETS, useKeymap, type Keymap } from "@/platform/keymap";
export { presetBindings, withBindings, type KeymapDraft };
export interface KeymapDraft {
preset: string;
overrides: Keymap;
}
/**
* The defaults of `id`: the preset's, or for an action the preset leaves out,
* the shortcut its plugin declares (`keymaps`). Removing or changing one is an
* override like any other.
*/
export function presetBindings(preset: string, id: string): string[] {
const own = PRESETS[preset];
const keys = own && id in own ? own[id] : useKeymap.getState().extensions?.[id];
return (keys ?? []).map(normalizeBinding);
}
export function resolveBindings(draft: KeymapDraft, id: string): string[] {
return draft.overrides[id]?.map(normalizeBinding) ?? presetBindings(draft.preset, id);
@@ -37,6 +41,17 @@ export function isModified(draft: KeymapDraft, id: string): boolean {
return id in draft.overrides;
}
const sameList = (a: readonly string[], b: readonly string[]) => a.length === b.length && a.every((x, i) => x === b[i]);
/** Sets the full binding list of `id`; drops the override when it equals the preset. */
export function withBindings(draft: KeymapDraft, id: string, bindings: readonly string[]): Keymap {
const list = [...new Set(bindings.map(normalizeBinding))];
const overrides = { ...draft.overrides };
if (sameList(list, presetBindings(draft.preset, id))) delete overrides[id];
else overrides[id] = list;
return overrides;
}
export function addBinding(draft: KeymapDraft, id: string, binding: string): Keymap {
return withBindings(draft, id, [...resolveBindings(draft, id), binding]);
}
@@ -220,13 +235,24 @@ export function validateKeymapName(name: string, customs: CustomKeymaps, ownId?:
return clash ? `Keymap '${n}' already exists` : null;
}
function newKeymapId(name: string, customs: CustomKeymaps): string {
const slug =
name
.toLowerCase()
.replace(/[^a-z0-9]+/g, "-")
.replace(/^-|-$/g, "") || "keymap";
let id = `custom.${slug}`;
for (let i = 2; customs[id] || PRESETS[id]; i++) id = `custom.${slug}-${i}`;
return id;
}
/** Copies the selected keymap (its effective overrides) under `name`; returns the new id. */
export function duplicateKeymap(
draft: KeymapDraft,
customs: CustomKeymaps,
name: string,
): { id: string; customs: CustomKeymaps } {
const id = customKeymapId(name, customs);
const id = newKeymapId(name, customs);
return {
id,
customs: { ...customs, [id]: { name: name.trim(), parent: draft.preset, overrides: { ...draft.overrides } } },
+8 -60
Переглянути файл
@@ -28,7 +28,7 @@ import { call, commands, isTauri, nextRequestId, type FileEntry } from "@/platfo
import { mergeLibraryGroups } from "@/platform/libraries";
import type { BuildModel, LibraryGroup, WebArtifact } from "@/bindings";
import { relativePath, useProject } from "@/platform/project";
import { PageContext, useSetting, useSettingsFormFor } from "../components/context";
import { PageContext, useSettingsFormFor } from "../components/context";
import {
applySettings,
closeProjectStructure,
@@ -61,7 +61,7 @@ import {
} from "@/platform/languageSettings";
import { initProjectRoots, useDetectedRoots } from "@/platform/projectRoots";
import { Row, Section } from "../components/Form";
import { detectSdks, forgetSdk, rememberSdk, useSdks, type SdkKind } from "./api";
import { detectSdks, useSdks, type SdkKind } from "./api";
import { choosePath } from "@/platform/choosePath";
import { DownloadJdkDialog } from "./DownloadJdkDialog";
import { SdkField, tildify, useDetected, useJdtlsJdk, useProjectSetting } from "./components";
@@ -1790,31 +1790,8 @@ function SdksSection() {
const [downloading, setDownloading] = useState(false);
const [selectedKey, setSelectedKey] = useState<string>("");
const [projectJdk, setProjectJdk] = useProjectSetting<string>("languages.java.jdk");
const [addedJdks, setAddedJdks] = useSetting<string[] | undefined>("languages.java.addedJdks", "global");
const [addError, setAddError] = useState<string | null>(null);
useDetected("jdk");
const addJdkFromDisk = async () => {
setAddError(null);
const picked = await choosePath({ directory: true, title: tx("Select Home Directory for JDK") });
if (!picked) return;
const sdk = await call(commands.sdkJdkAt(picked)).catch(() => null);
if (!sdk) {
setAddError(tx`The selected directory is not a valid home for JDK: ${tildify(picked)}`);
return;
}
const added = addedJdks ?? [];
if (!added.includes(sdk.path)) setAddedJdks([...added, sdk.path]);
rememberSdk("jdk", { ...sdk, source: "added" });
setSelectedKey(`jdk:${sdk.path}`);
};
const removeAddedJdk = (path: string) => {
setAddedJdks((addedJdks ?? []).filter((p) => p !== path));
forgetSdk("jdk", path);
setSelectedKey("");
};
useEffect(() => {
for (const { kind } of SDK_KINDS) {
void detectSdks(kind);
@@ -1828,15 +1805,8 @@ function SdksSection() {
};
const rows = useMemo(() => {
const out: Array<{
key: string;
kind: SdkKind;
kindLabel: string;
name: string;
version: string;
path: string;
added: boolean;
}> = [];
const out: Array<{ key: string; kind: SdkKind; kindLabel: string; name: string; version: string; path: string }> =
[];
for (const { kind, label } of SDK_KINDS) {
for (const sdk of byKind[kind] ?? []) {
out.push({
@@ -1846,12 +1816,11 @@ function SdksSection() {
name: sdk.name,
version: sdk.version ?? "",
path: sdk.path,
added: kind === "jdk" && (sdk.source === "added" || (addedJdks ?? []).includes(sdk.path)),
});
}
}
return out;
}, [byKind, addedJdks]);
}, [byKind]);
const activeSdk = rows.find((r) => r.key === selectedKey) ?? rows[0];
@@ -1860,33 +1829,12 @@ function SdksSection() {
<div className={styles.splitLayout}>
<div className={styles.sideList}>
<div className={styles.tableToolbar}>
<IconButton
icon="plus"
size="small"
title="Add SDK"
onClick={(e) => {
const r = e.currentTarget.getBoundingClientRect();
showContextMenu({ x: r.left, y: r.bottom + 2 }, [
{ label: tx("Download JDK…"), icon: "download", run: () => setDownloading(true) },
{ label: tx("Add JDK from Disk…"), icon: "folder-open", run: () => void addJdkFromDisk() },
]);
}}
/>
<IconButton
icon="minus"
size="small"
title="Remove SDK"
disabled={!activeSdk?.added}
onClick={() => activeSdk && removeAddedJdk(activeSdk.path)}
/>
<Button size="small" variant="ghost" icon="plus" onClick={() => setDownloading(true)}>
<T>Download JDK…</T>
</Button>
<span className={styles.spacer} />
<IconButton icon="refresh" size="small" title="Detect again" onClick={refreshAll} />
</div>
{addError && (
<div className={styles.error} role="alert">
{addError}
</div>
)}
<div className={styles.sideItems} role="listbox" aria-label={tx("SDKs")}>
{rows.length === 0 && (
<div className={styles.empty}>
-5
Переглянути файл
@@ -63,11 +63,6 @@ export function detectSdks(kind: SdkKind, force = false): Promise<Sdk[]> {
return p;
}
/** Drops an SDK (e.g. a JDK added by hand, then removed) from the cached list. */
export function forgetSdk(kind: SdkKind, path: string) {
useSdks.setState((s) => ({ byKind: { ...s.byKind, [kind]: (s.byKind[kind] ?? []).filter((x) => x.path !== path) } }));
}
/** Adds an SDK (e.g. a just-created virtualenv) to the cached list. */
export function rememberSdk(kind: SdkKind, sdk: Sdk) {
const remember = () =>
+30 -16
Переглянути файл
@@ -1,9 +1,8 @@
/**
* CodeMirror setup for the VCS viewers (diff, merge, local history): token
* based theme + syntax colours and lazy language loading through the editor's
* language pipeline, so colours match the editor.
* based theme + syntax colours and lazy language loading by file name.
*/
import { syntaxHighlighting, type LanguageSupport } from "@codemirror/language";
import { HighlightStyle, LanguageDescription, syntaxHighlighting, type LanguageSupport } from "@codemirror/language";
import {
Compartment,
EditorState,
@@ -33,9 +32,8 @@ import {
import { getChunks, mergeViewSiblings, type Chunk } from "@codemirror/merge";
import { defaultKeymap } from "@codemirror/commands";
import { search, searchKeymap } from "@codemirror/search";
import { tags as t } from "@lezer/highlight";
import { scrollbarMarks, type ScrollbarMark } from "@/editor/api";
import { openideaHighlightStyle } from "@/editor/core/cm/highlight";
import { findLanguageDescription, loadSupport, uiModeForPath } from "@/editor/core/cm/languages";
import { findExtension } from "@/editor/core/cm/find";
import { overviewLane, overviewLaneIn } from "@/editor/core/cm/lanes";
import { LINE_INSET } from "@/editor/core/cm/lineInset";
@@ -296,6 +294,26 @@ export const diffWords: Extension = [
EditorView.editorAttributes.of({ class: "cm-diffWords" }),
];
export const viewerHighlight = HighlightStyle.define([
{
tag: [t.keyword, t.modifier, t.controlKeyword, t.operatorKeyword, t.definitionKeyword],
color: "var(--syn-keyword)",
},
{ tag: [t.string, t.special(t.string), t.regexp, t.character], color: "var(--syn-string)" },
{ tag: [t.typeName, t.className, t.namespace, t.tagName], color: "var(--syn-type)" },
{ tag: [t.function(t.variableName), t.function(t.propertyName)], color: "var(--syn-function)" },
{ tag: [t.comment, t.lineComment, t.blockComment, t.docComment], color: "var(--syn-comment)", fontStyle: "italic" },
{ tag: [t.annotation, t.meta, t.attributeName], color: "var(--syn-annotation)" },
{ tag: [t.number, t.bool, t.null, t.atom], color: "var(--syn-number)" },
{ tag: [t.constant(t.variableName), t.standard(t.variableName)], color: "var(--syn-constant)" },
{ tag: [t.punctuation, t.bracket, t.operator], color: "var(--syn-punct)" },
{ tag: [t.propertyName], color: "var(--syn-property)" },
{ tag: [t.variableName], color: "var(--syn-variable)" },
{ tag: t.invalid, color: "var(--syn-invalid)" },
{ tag: t.heading, fontWeight: "var(--fw-code-bold, 700)", color: "var(--fg-strong)" },
{ tag: t.link, color: "var(--link)", textDecoration: "underline" },
]);
export const viewerTheme = EditorView.theme(
{
...overviewStyles,
@@ -512,7 +530,7 @@ export function viewerBase(opts: {
opts.findBar
? [findExtension(), keymap.of(defaultKeymap)]
: [search({ top: true }), keymap.of([...searchKeymap, ...defaultKeymap])],
syntaxHighlighting(openideaHighlightStyle),
syntaxHighlighting(viewerHighlight),
viewerTheme,
changedLines,
EditorState.readOnly.of(opts.readOnly),
@@ -522,22 +540,18 @@ export function viewerBase(opts: {
];
}
let languagesPromise: Promise<readonly LanguageDescription[]> | null = null;
const cache = new Map<string, Promise<LanguageSupport | null>>();
/**
* Loads the language for `fileName` through the editor's pipeline
* (`findLanguageDescription` + `loadSupport`): the same modes, tag patches and
* `data-language` attribute as the editor, so colours match. Unknown
* extensions resolve like the editor's (null once the backend languages are
* loaded, file-name match before that).
*/
/** Loads the language for `fileName` (by extension / name), or null. */
export function languageFor(fileName: string): Promise<LanguageSupport | null> {
const name = fileName.slice(fileName.lastIndexOf("/") + 1);
const hit = cache.get(name);
if (hit) return hit;
const p = Promise.resolve(uiModeForPath(fileName))
.then((uiMode) => findLanguageDescription(uiMode ?? null, fileName))
.then((desc) => (desc ? loadSupport(desc) : null))
languagesPromise ??= import("@codemirror/language-data").then((m) => m.languages);
const p = languagesPromise
.then((langs) => LanguageDescription.matchFilename(langs, name))
.then((desc) => (desc ? desc.load() : null))
.catch(() => null);
cache.set(name, p);
return p;
-40
Переглянути файл
@@ -730,43 +730,3 @@ export function installKeyboardDispatcher(
target.removeEventListener("blur", onBlur);
};
}
/** A keymap being edited: a bundled preset and the overrides on top of it. */
export interface KeymapDraft {
preset: string;
overrides: Keymap;
}
/**
* The defaults of `id`: the preset's, or for an action the preset leaves out,
* the shortcut its plugin declares (`keymaps`). Removing or changing one is an
* override like any other.
*/
export function presetBindings(preset: string, id: string): string[] {
const own = PRESETS[preset];
const keys = own && id in own ? own[id] : useKeymap.getState().extensions?.[id];
return (keys ?? []).map(normalizeBinding);
}
const sameList = (a: readonly string[], b: readonly string[]) => a.length === b.length && a.every((x, i) => x === b[i]);
/** Sets the full binding list of `id`; drops the override when it equals the preset. */
export function withBindings(draft: KeymapDraft, id: string, bindings: readonly string[]): Keymap {
const list = [...new Set(bindings.map(normalizeBinding))];
const overrides = { ...draft.overrides };
if (sameList(list, presetBindings(draft.preset, id))) delete overrides[id];
else overrides[id] = list;
return overrides;
}
/** A free id for a user keymap called `name`. */
export function customKeymapId(name: string, customs: Record<string, unknown>): string {
const slug =
name
.toLowerCase()
.replace(/[^a-z0-9]+/g, "-")
.replace(/^-|-$/g, "") || "keymap";
let id = `custom.${slug}`;
for (let i = 2; customs[id] || PRESETS[id]; i++) id = `custom.${slug}-${i}`;
return id;
}
+1 -36
Переглянути файл
@@ -465,8 +465,6 @@
"These settings will be imported:": "These settings will be imported:",
"Not imported:": "Not imported:",
"Current color scheme": "Current color scheme",
"Current keymap": "Current keymap",
"Code Style options other than Tabs and Indents": "Code Style options other than Tabs and Indents",
"No settings OpenIDEA can import were found": "No settings OpenIDEA can import were found",
"Overwrite existing branch": "Overwrite existing branch",
"Unset upstream branch": "Unset upstream branch",
@@ -1979,38 +1977,5 @@
"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.",
"{label} data source": "{label} data source",
"{label} schema": "{label} schema",
"Migrates {to} to match {from}": "Migrates {to} to match {from}",
"Migration script copied": "Migration script copied",
"Compare Structure": "Compare Structure",
"Compare Structure…": "Compare Structure…",
"Compare the tables of two schemas and write the migration SQL from one to the other": "Compare the tables of two schemas and write the migration SQL from one to the other",
"Open in Console": "Open in Console",
"Show only differences": "Show only differences",
"{differences} of {length} tables differ": "{differences} of {length} tables differ",
"Cannot compare": "Cannot compare",
"Reading the schemas…": "Reading the schemas…",
"Pick a source and a target schema, then Compare": "Pick a source and a target schema, then Compare",
"Differences": "Differences",
"The schemas have the same structure": "The schemas have the same structure",
"Migration script": "Migration script",
"Only in source": "Only in source",
"Only in target": "Only in target",
"Different": "Different",
"Identical": "Identical",
"Source": "Source",
"Target": "Target",
"Foreign Keys": "Foreign Keys",
"Indexes": "Indexes",
"Columns": "Columns",
"Add JDK from Disk…": "Add JDK from Disk…",
"Select Home Directory for JDK": "Select Home Directory for JDK",
"The selected directory is not a valid home for JDK: {path}": "The selected directory is not a valid home for JDK: {path}",
"Add SDK": "Add SDK",
"Remove SDK": "Remove SDK",
"{rel} is added to your request": "{rel} is added to your request",
"IDE Context Enabled: the current file and selection are added to your request": "IDE Context Enabled: the current file and selection are added to your request",
"IDE Context Disabled: the current file and selection are not added to your request": "IDE Context Disabled: the current file and selection are not added to your request"
"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."
}
+1 -32
Переглянути файл
@@ -3512,8 +3512,6 @@
"These settings will be imported:": "将导入以下设置:",
"Not imported:": "不导入:",
"Current color scheme": "当前配色方案",
"Current keymap": "当前按键映射",
"Code Style options other than Tabs and Indents": "制表符和缩进以外的代码样式选项",
"No settings OpenIDEA can import were found": "没有找到 OpenIDEA 可以导入的设置",
"Rename Project": "重命名项目",
"Rename Project…": "重命名项目…",
@@ -8371,34 +8369,5 @@
"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.": "路径相对于项目根目录。对某个文件生效的是包含它的最深一级文件夹或该文件本身。",
"{label} data source": "{label}数据源",
"{label} schema": "{label}架构",
"Migrates {to} to match {from}": "迁移 {to},使其与 {from} 一致",
"Migration script copied": "已复制迁移脚本",
"Compare Structure": "比较结构",
"Compare Structure…": "比较结构…",
"Compare the tables of two schemas and write the migration SQL from one to the other": "比较两个架构的表,并生成从一个迁移到另一个的 SQL",
"Open in Console": "在控制台中打开",
"Show only differences": "仅显示差异",
"{differences} of {length} tables differ": "{length} 个表中有 {differences} 个不同",
"Cannot compare": "无法比较",
"Reading the schemas…": "正在读取架构…",
"Pick a source and a target schema, then Compare": "选择源架构和目标架构,然后点击“比较”",
"Differences": "差异",
"The schemas have the same structure": "两个架构的结构相同",
"Migration script": "迁移脚本",
"Only in source": "仅在源中",
"Only in target": "仅在目标中",
"Different": "不同",
"Foreign Keys": "外键",
"Indexes": "索引",
"Add JDK from Disk…": "从磁盘添加 JDK…",
"Select Home Directory for JDK": "选择 JDK 主目录",
"The selected directory is not a valid home for JDK: {path}": "所选目录不是有效的 JDK 主目录:{path}",
"Add SDK": "添加 SDK",
"Remove SDK": "移除 SDK",
"{rel} is added to your request": "{rel} 会添加到你的请求中",
"IDE Context Enabled: the current file and selection are added to your request": "IDE 上下文已启用:当前文件和所选内容会添加到你的请求中",
"IDE Context Disabled: the current file and selection are not added to your request": "IDE 上下文已禁用:当前文件和所选内容不会添加到你的请求中"
"Paths are relative to the project root. The deepest folder or file that contains a file applies to it.": "路径相对于项目根目录。对某个文件生效的是包含它的最深一级文件夹或该文件本身。"
}
-39
Переглянути файл
@@ -1,39 +0,0 @@
import { afterEach, beforeEach, expect, it, vi } from "vitest";
beforeEach(() => {
vi.useFakeTimers({ toFake: ["setTimeout", "requestAnimationFrame"] });
vi.resetModules();
document.body.innerHTML = '<div id="splash" class="splash"></div>';
});
afterEach(() => vi.useRealTimers());
const splash = () => document.getElementById("splash");
it("gives up on a slow launch after its time limit", async () => {
const { holdSplash, hideSplash } = await import("./splash");
holdSplash(new Promise(() => {}));
hideSplash();
await vi.advanceTimersByTimeAsync(5000);
expect(splash()).toBeNull();
});
it("stays up, under dialogs, until a question asked while the window opens is answered", async () => {
const { askOverSplash, holdSplash, hideSplash } = await import("./splash");
let answer!: (open: boolean) => void;
const question = new Promise<boolean>((resolve) => (answer = resolve));
holdSplash(question);
hideSplash();
askOverSplash(question);
expect(splash()?.classList.contains("splash-under-dialogs")).toBe(true);
await vi.advanceTimersByTimeAsync(60_000);
expect(splash()).not.toBeNull();
answer(false);
await vi.advanceTimersByTimeAsync(1000);
expect(splash()).toBeNull();
});
it("leaves a page without a splash alone", async () => {
document.body.innerHTML = "";
const { askOverSplash } = await import("./splash");
expect(() => askOverSplash(Promise.resolve(true))).not.toThrow();
});
Loaded 100 of 105 files, more files were not shown because too many files have changed in this diff. Show more