дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-16 06:35:40 +02:00
Порівняти коміти
1
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
69633262cf |
No files matched your search
@@ -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})]);
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
|
||||
@@ -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 },
|
||||
|
||||
@@ -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> {
|
||||
|
||||
@@ -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]);
|
||||
}
|
||||
}
|
||||
@@ -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}"
|
||||
);
|
||||
}
|
||||
@@ -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"),
|
||||
|
||||
@@ -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 } }
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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")
|
||||
};
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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<()> {
|
||||
|
||||
@@ -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)?;
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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"
|
||||
]
|
||||
);
|
||||
|
||||
@@ -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);
|
||||
});
|
||||
@@ -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(),
|
||||
},
|
||||
});
|
||||
@@ -1,9 +0,0 @@
|
||||
<!doctype html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
</head>
|
||||
<body>
|
||||
<script type="module" src="./inlayRequests.fixture.ts"></script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -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");
|
||||
});
|
||||
@@ -1,6 +0,0 @@
|
||||
id = "gherkin"
|
||||
name = "Gherkin"
|
||||
extensions = ["feature"]
|
||||
line-comment = "#"
|
||||
indent = { tab-size = 2, insert-spaces = true }
|
||||
ui-mode = "Gherkin"
|
||||
@@ -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));
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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> {
|
||||
|
||||
@@ -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 [
|
||||
|
||||
@@ -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 },
|
||||
};
|
||||
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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();
|
||||
});
|
||||
});
|
||||
@@ -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)]);
|
||||
}
|
||||
@@ -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)");
|
||||
});
|
||||
|
||||
@@ -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 ||
|
||||
|
||||
@@ -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,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");
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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"]);
|
||||
});
|
||||
});
|
||||
@@ -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)));
|
||||
|
||||
@@ -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…"
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
|
||||
@@ -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}
|
||||
|
||||
@@ -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(() => {
|
||||
|
||||
@@ -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>();
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
|
||||
@@ -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([]);
|
||||
});
|
||||
|
||||
@@ -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" }));
|
||||
}
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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 };
|
||||
|
||||
@@ -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");
|
||||
});
|
||||
});
|
||||
@@ -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"],
|
||||
};
|
||||
@@ -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",
|
||||
|
||||
@@ -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());
|
||||
};
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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!);
|
||||
});
|
||||
});
|
||||
@@ -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) => {
|
||||
|
||||
@@ -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 (
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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>
|
||||
);
|
||||
}
|
||||
@@ -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,
|
||||
};
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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);
|
||||
});
|
||||
});
|
||||
@@ -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),
|
||||
];
|
||||
}
|
||||
@@ -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");
|
||||
});
|
||||
});
|
||||
@@ -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` : "";
|
||||
}
|
||||
@@ -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 > 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);
|
||||
});
|
||||
});
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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])];
|
||||
}
|
||||
@@ -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);
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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":
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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}
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
});
|
||||
@@ -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();
|
||||
});
|
||||
@@ -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 } } };
|
||||
}
|
||||
@@ -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 } } },
|
||||
|
||||
@@ -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}>
|
||||
|
||||
@@ -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 = () =>
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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."
|
||||
}
|
||||
@@ -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.": "路径相对于项目根目录。对某个文件生效的是包含它的最深一级文件夹或该文件本身。"
|
||||
}
|
||||
@@ -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
Reference in new issue
Заблокувати користувача