дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-17 23:25:45 +02:00
Порівняти коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
69633262cf |
No files matched your search
@@ -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() {
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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"
|
||||
@@ -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)]);
|
||||
}
|
||||
@@ -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"],
|
||||
|
||||
@@ -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"]);
|
||||
});
|
||||
});
|
||||
@@ -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}
|
||||
|
||||
@@ -11,10 +11,7 @@ const component = (name: string, options: Record<string, string>) =>
|
||||
.map(([k, v]) => `<option name="${k}" value="${v}" />`)
|
||||
.join("")}</component></application>`;
|
||||
|
||||
const editor = { fontFamily: "JetBrains Mono", fontSize: 13, customSchemes: {}, colorOverrides: {} };
|
||||
|
||||
/** JetBrains Maple Mono's metrics (ascent 1.02em, descent 0.3em), for any family. */
|
||||
const fontHeight = (_family: string, size: number) => Math.ceil(size * 1.02) + Math.ceil(size * 0.3);
|
||||
const editor = { fontSize: 13, customSchemes: {}, colorOverrides: {} };
|
||||
|
||||
/** A WebStorm export, trimmed to what the import reads. */
|
||||
const webstorm = {
|
||||
@@ -54,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, editor, 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]!;
|
||||
@@ -65,8 +62,6 @@ 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",
|
||||
@@ -88,8 +83,8 @@ describe("planJetBrainsImport", () => {
|
||||
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: {
|
||||
@@ -103,50 +98,32 @@ describe("planJetBrainsImport", () => {
|
||||
},
|
||||
},
|
||||
editor,
|
||||
fontHeight,
|
||||
);
|
||||
expect(plan.writes).toEqual([
|
||||
// (14 + 4) × 1.5
|
||||
["editor.lineHeight", 27],
|
||||
["editor.lineHeight", 20],
|
||||
["files.trimTrailingWhitespace", false],
|
||||
["editor.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, editor, fontHeight)).writes);
|
||||
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,
|
||||
{
|
||||
...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" }) } },
|
||||
editor,
|
||||
() => undefined,
|
||||
);
|
||||
expect(plan.writes).toEqual([
|
||||
["editor.fontSize", 20],
|
||||
["editor.lineHeight", 29],
|
||||
]);
|
||||
});
|
||||
|
||||
it("skips colour schemes that cannot be read", async () => {
|
||||
const plan = await planJetBrainsImport({ entries: [], files: { "colors/broken.icls": "<nope" } }, editor);
|
||||
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) => {
|
||||
@@ -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" }));
|
||||
}
|
||||
|
||||
@@ -8,7 +8,6 @@
|
||||
import { Fragment } from "react";
|
||||
import type { JetBrainsSettings } from "@/bindings";
|
||||
import { customSchemes } from "@/platform/colorScheme";
|
||||
import { createFontProbeCanvas, fontsLoaded, monoFontFamily } from "@/platform/fonts";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { importScheme, parseIcls } from "@/platform/icls";
|
||||
import { call, commands } from "@/platform/ipc";
|
||||
@@ -29,7 +28,6 @@ export interface JetBrainsImportPlan {
|
||||
}
|
||||
|
||||
interface EditorState {
|
||||
fontFamily: string;
|
||||
fontSize: number | null;
|
||||
customSchemes: unknown;
|
||||
colorOverrides: Record<string, unknown>;
|
||||
@@ -65,39 +63,7 @@ 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();
|
||||
}
|
||||
}
|
||||
|
||||
export async function planJetBrainsImport(
|
||||
bundle: JetBrainsSettings,
|
||||
editor: EditorState,
|
||||
fontHeight: FontHeight = measuredFontHeight,
|
||||
): Promise<JetBrainsImportPlan> {
|
||||
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;
|
||||
@@ -135,18 +101,12 @@ export async function planJetBrainsImport(
|
||||
}
|
||||
|
||||
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 ed = options(bundle.files["options/editor.xml"], "EditorSettings");
|
||||
@@ -214,7 +174,7 @@ function Summary({ plan }: { plan: JetBrainsImportPlan }) {
|
||||
export async function importJetBrainsSettings(path: string) {
|
||||
const bundle = await call(commands.settingsReadJetbrains(path));
|
||||
const { editor } = await commands.settingsGetGlobal();
|
||||
const plan = await planJetBrainsImport(bundle, editor);
|
||||
const plan = planJetBrainsImport(bundle, editor);
|
||||
if (!plan.writes.length) {
|
||||
notifications().notify({
|
||||
level: "warning",
|
||||
|
||||
@@ -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}
|
||||
|
||||
@@ -1977,30 +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"
|
||||
"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."
|
||||
}
|
||||
@@ -8369,26 +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": "索引"
|
||||
"Paths are relative to the project root. The deepest folder or file that contains a file applies to it.": "路径相对于项目根目录。对某个文件生效的是包含它的最深一级文件夹或该文件本身。"
|
||||
}
|
||||
@@ -39,8 +39,6 @@
|
||||
.sizer {
|
||||
position: relative;
|
||||
width: 100%;
|
||||
/* Keeps the tint bands of rows above the tree's background. */
|
||||
isolation: isolate;
|
||||
}
|
||||
.row {
|
||||
position: absolute;
|
||||
@@ -70,15 +68,16 @@
|
||||
.row:hover {
|
||||
background: var(--bg-tree-hover, color-mix(in srgb, var(--fg-strong) 4%, transparent));
|
||||
}
|
||||
/* File Colors: a full-width band under the row, so runs of tinted rows read as one block;
|
||||
hover and selection stay rounded on top of it. */
|
||||
.tinted::before {
|
||||
content: "";
|
||||
position: absolute;
|
||||
inset: 0 calc(-1 * var(--tree-inset, 6px));
|
||||
z-index: -1;
|
||||
background: color-mix(in srgb, var(--row-tint) var(--row-tint-strength, var(--file-tint-strength, 14%)), transparent);
|
||||
pointer-events: none;
|
||||
/* File Colors: the row's background takes its scope's colour. */
|
||||
.tinted {
|
||||
background: color-mix(in srgb, var(--row-tint) var(--file-tint-strength, 14%), transparent);
|
||||
}
|
||||
.tinted:hover {
|
||||
background: color-mix(
|
||||
in srgb,
|
||||
var(--row-tint) var(--file-tint-strength, 14%),
|
||||
var(--bg-tree-hover, color-mix(in srgb, var(--fg-strong) 4%, transparent))
|
||||
);
|
||||
}
|
||||
/* Tree.selectionInactiveBackground when unfocused, selectionBackground when focused. */
|
||||
.selected,
|
||||
|
||||
@@ -179,7 +179,6 @@ const ICONS = {
|
||||
"file-gdshader": "openidea/fileTypes/gdshader",
|
||||
"file-asciidoc": "openidea/fileTypes/asciidoc",
|
||||
"file-d": "openidea/fileTypes/d",
|
||||
"file-gherkin": "openidea/fileTypes/gherkin",
|
||||
"file-prisma": "openidea/fileTypes/prisma",
|
||||
"file-slint": "openidea/fileTypes/slint",
|
||||
"file-dart": "openidea/fileTypes/dart",
|
||||
@@ -1149,7 +1148,6 @@ const EXT_ICONS = table({
|
||||
"file-gdshader": "gdshader gdshaderinc",
|
||||
"file-asciidoc": "adoc asciidoc",
|
||||
"file-d": "d di",
|
||||
"file-gherkin": "feature",
|
||||
"file-prisma": "prisma",
|
||||
"file-slint": "slint",
|
||||
"file-dart": "dart",
|
||||
|
||||
@@ -1,3 +0,0 @@
|
||||
<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
|
||||
<g stroke-linejoin="round"><path d="M14 4C14 2.89543 13.1046 2 12 2H4C2.89543 2 2 2.89543 2 4V12C2 13.1046 2.89543 14 4 14H12C13.1046 14 14 13.1046 14 12V4Z" fill="#4E9A42"/><ellipse cx="8" cy="8" rx="2.4" ry="4.2" transform="rotate(35 8 8)" stroke="#2B2D30"/><path d="M7.4 6.6H7.6M8.4 9.4H8.6" stroke="#2B2D30" stroke-linecap="round"/></g>
|
||||
</svg>
|
||||
|
До Ширина: | Висота: | Розмір: 444 B |
@@ -1,3 +0,0 @@
|
||||
<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
|
||||
<g stroke-linejoin="round"><path d="M14 4C14 2.89543 13.1046 2 12 2H4C2.89543 2 2 2.89543 2 4V12C2 13.1046 2.89543 14 4 14H12C13.1046 14 14 13.1046 14 12V4Z" fill="#5FAD52"/><ellipse cx="8" cy="8" rx="2.4" ry="4.2" transform="rotate(35 8 8)" stroke="#2B2D30"/><path d="M7.4 6.6H7.6M8.4 9.4H8.6" stroke="#2B2D30" stroke-linecap="round"/></g>
|
||||
</svg>
|
||||
|
До Ширина: | Висота: | Розмір: 444 B |
Reference in new issue
Заблокувати користувача