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

...
Автор SHA1 Повідомлення Дата
l0ng-ai 8af09aaf58 fix(tools): install debugpy when the project's Python has no pip
debugpy's private copy was made with `python -m pip` of the selected interpreter.
A virtualenv made by uv has no pip, so with such a project interpreter the
install failed with "No module named pip". The copy is a universal wheel and
doesn't need that interpreter's pip: when it has none, pip runs through
`uv tool run pip`, or another Python on PATH that has pip.
2026-11-16 11:25:03 +08:00
Deng Liuтаdengliu 0b097808f1 fix(agents): increase process-run step indentation and align running tool icons (#3636)
Expanded process runs and turn folds read nearly flat: the guide line sat left of the summary chevron, nested chevrons indented by only a few pixels, and tool rows without output yet had no chevron slot, so their icon jumped right once output arrived. The guide now drops from the parent chevron's centre, tool calls after a thought indent under it, expanded output indents with its row, and output-less tool rows reserve the chevron's width.

Co-authored-by: dengliu <[email protected]>
2026-11-16 11:10:18 +08:00
LU XIANGRUIтаwildcatDownstairs 6cc4b3779c fix(settings): import the JetBrains line height from the font's own height (#3640)
The imported line height was font size × LINE_SPACING and was only written when the export had LINE_SPACING, so tall fonts came out cramped and the default spacing (left out of the export) never applied. It is now the font's measured height (ascent + descent, rounded up per side) × LINE_SPACING (1.2 when absent), written whenever the export sets a font, size or spacing; size × 1.2 is the fallback when the font cannot be measured.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-16 11:08:13 +08:00
Muuтаmuutot 7d9efa1997 fix(plugins): deliver the post-install settings event to a freshly installed plugin (#3642)
The UI posts a synthetic settings-changed right after an install so event-driven plugins get a first delivery, but changed_settings() took its first snapshot on that call and reported an empty diff, so the event was dropped and the plugin stayed inactive until something else happened in the window. With no snapshot yet for a (window, plugin), it now hands over the current keys; later calls still report only the diff.

Co-authored-by: muutot <[email protected]>
2026-11-16 11:07:37 +08:00
GuoYuтаguoyucode af2e45883d fix(lsp): give a project attached inside the root its own language server (#3643)
Since attached projects inside the root were left out of the content roots (the index already walks them), the language-server manager routed their files to the outer project's server, whose workspace does not contain them (rust-analyzer: "file is not included in any crate"). The manager now gets the content roots plus the projects attached inside the root; index roots are unchanged.

Co-authored-by: guoyucode <[email protected]>
2026-11-16 11:04:29 +08:00
acaoтаamphetamlne 17e11b7904 fix(lsp): bound and cancel Go module deprecation queries (#3333)
The go.mod deprecation query (go list -m -u) could wait indefinitely on a proxy or toolchain download, and superseded checks kept running. Bound it to 60 s and 8 MiB of stdout; a new check of the same document, closing it, revoking execution permission or shutting down cancels it. A supervisor task kills and reaps the process tree even if the caller is dropped; failed or cancelled checks publish nothing.

Co-authored-by: amphetamlne <[email protected]>
2026-11-16 11:01:05 +08:00
acaoтаamphetamlne 22aa1edd61 fix(editor): discard obsolete inlay hint responses (#3253)
Inlay hint requests only checked whether the document had changed, so an older response (e.g. for the previous viewport) could replace newer hints, or restore hints after they were disabled. A refresh or destroy now bumps a generation; work that is no longer wanted is skipped after document sync, before applying results and before marking the server unavailable.

Co-authored-by: amphetamlne <[email protected]>
2026-11-16 10:59:48 +08:00
acaoтаamphetamlne 07c862c785 fix(workspace): detect marked environments before directory-name skips (#3241)
Root detection skipped dot-prefixed and conventional directory names (.venv, venv, .conda) before checking the pyvenv.cfg / conda-meta markers, so those environments were never recorded as excluded roots and their packages could reach the index and VFS walk. Check the markers first; the name-based skip still stops traversal.

Co-authored-by: amphetamlne <[email protected]>
2026-11-16 10:58:53 +08:00
l0ng-ai b60dad7076 feat(languages): Gherkin feature files (#3645)
.feature files are recognised as Gherkin: syntax colours for keywords in every Gherkin language, tags, tables, doc strings and outline placeholders; line comments, two-space indentation, a file icon, and folding of each section, step argument and doc string by indentation.

Part of #797
2026-11-16 10:56:23 +08:00
l0ng-ai 148e45745a feat(database): compare the structure of two schemas (#3644)
Compare Structure picks a source and a target schema, reads their tables with columns, indexes and foreign keys, and shows the differences as a tree (only in source, only in target, different), hiding identical items on request. Checked differences become the migration script that makes the target match the source in the target dialect; changes a dialect cannot express are left as comments. The script is copied or opened in a console of the target; nothing is run.

Closes #2694
2026-11-16 10:52:21 +08:00
l0ng-ai 3287061ea1 feat(database): SQL in MyBatis mapper XML (#3641)
The statements of <select>, <insert>, <update>, <delete> and <sql> in a MyBatis mapper are highlighted as SQL in the data source dialect and get completion, unresolved table/column inspections, Go to Declaration and Quick Documentation against the data source of the file SQL resolution scope (or the only data source). The SQL tools read the mapper with everything but the statements blanked out, so offsets stay the file own; parameters, entities, CDATA, selectKey, comments and the dynamic tags where/set/trim/foreach are read the way MyBatis builds the SQL.

Closes #2457
2026-11-16 10:44:48 +08:00
l0ng-ai 223beeb374 chore(debugger): drop an unused re-export of openAttachPopup (#3639)
pnpm knip failed on main: actions.ts re-exported openAttachPopup, which every caller imports from ./attachPopup directly.
2026-11-16 10:39:30 +08:00
l0ng-ai 8b9ad2e9d1 feat(database): SQL resolution scopes (#3638)
Settings › Languages & Frameworks › SQL Resolution Scopes maps project folders and files to a data source and schema (project settings, database.resolutionScopes). SQL files in a mapped folder resolve against its data source for completion, inspections, navigation and the console toolbar, unless another data source is picked in the toolbar; the deepest row wins and the Project row applies elsewhere. Contributed settings pages can start on the project scope (defaultScope).

Part of #2457
2026-11-16 10:38:58 +08:00
57 змінених файлів з 2969 додано та 104 видалено

No files matched your search

+1 -1
Переглянути файл
@@ -71,7 +71,7 @@ pub struct Settings {
pub scopes: Vec<NamedScope>,
/// Appearance & Behavior › File Colors.
pub file_colors: FileColorSettings,
/// Database › Query Execution.
/// Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes.
pub database: DatabaseSettings,
/// Plugin settings (`[contributes.settings]`): plugin id → its values by key.
#[specta(type = BTreeMap<String, BTreeMap<String, specta_typescript::Unknown>>)]
+16 -1
Переглянути файл
@@ -241,13 +241,28 @@ impl Default for LogLevelColors {
}
}
/// Database › Query Execution.
/// Database settings: Query Execution and SQL Resolution Scopes.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct DatabaseSettings {
/// A console's result sets show under the statements that produced them, in the editor,
/// instead of in the Services view's result tabs.
pub in_editor_results: bool,
/// Languages & Frameworks › SQL Resolution Scopes: the data source SQL in a file or folder
/// resolves against (completion, inspections, navigation), most specific path first.
pub resolution_scopes: Vec<SqlResolutionScope>,
}
/// One row of SQL Resolution Scopes.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct SqlResolutionScope {
/// Project-relative file or folder, `/`-separated; empty for the whole project.
pub path: String,
/// Data source id.
pub data_source: String,
/// Schema unqualified names resolve in; empty for the data source's default.
pub schema: String,
}
/// Build, Execution, Deployment › Console.
+8 -3
Переглянути файл
@@ -677,9 +677,14 @@ impl Shared {
}
let previous =
self.setting_snapshots.lock().insert((client.map(str::to_owned), pkg.id().into()), current.clone());
previous
.map(|old| current.into_iter().filter(|(k, v)| old.get(k) != Some(v)).map(|(k, _)| k).collect())
.unwrap_or_default()
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(),
}
}
pub fn status_snapshot(&self, client: &str) -> Vec<super::PluginStatusItem> {
+39 -2
Переглянути файл
@@ -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(extra_roots.clone());
lsp.set_content_roots(language_server_roots(&root, 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(roots.clone());
self.lsp.set_content_roots(language_server_roots(&self.root, roots.clone()));
self.lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
&self.root,
&self.settings.effective().languages.java.maven.linked_projects,
@@ -1369,6 +1369,22 @@ 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 —
@@ -2163,4 +2179,25 @@ 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]);
}
}
+26 -2
Переглянути файл
@@ -6271,10 +6271,15 @@ 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(), 3, "{received}");
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[0]["kind"], "settings-changed");
assert_eq!(events[0]["data"], "[\"enabled\"]");
assert_eq!(events[2]["kind"], "input-mode-changed");
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]["editor"][0], path);
assert_eq!(events[2]["editor"][1][0], serde_json::json!([0, 0, 0, 0]));
}
@@ -7016,3 +7021,22 @@ fn the_language_server_grant_needs_api_1_9() {
let err = f.host.install_from_dir(&pkg, &Consent::all()).unwrap_err();
assert!(err.message.contains("new in plugin API 1.9"), "{err:?}");
}
/// The UI's synthetic post-install `SettingsChanged([])` reaches a plugin that
/// subscribes to `on-event:settings-changed`, though it carries no keys.
#[test]
fn a_freshly_installed_plugin_gets_the_post_install_settings_event() {
let f = fixture(Limits::default());
f.install(&sample("api14"));
use ide_plugin::WorkbenchEvent as E;
// What refreshEventKinds() posts right after commandsChanged (install).
f.host.post_events(Some("main"), vec![E::SettingsChanged(Vec::new())]);
f.host.flush_events_at(Instant::now() + Duration::from_secs(2));
assert!(f.host.wait_events(Duration::from_secs(5)));
let received: serde_json::Value = serde_json::from_str(&f.run("api14", "events", None).unwrap().unwrap()).unwrap();
let events = received.as_array().unwrap();
assert!(
events.iter().any(|e| e["kind"] == "settings-changed"),
"freshly installed plugin got no post-install event: {received}"
);
}
+2
Переглянути файл
@@ -33,6 +33,7 @@ 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")),
@@ -1057,6 +1058,7 @@ mod tests {
("CMakeLists.txt", "cmake"),
("api.proto", "proto"),
("schema.graphql", "graphql"),
("checkout.feature", "gherkin"),
("schema.prisma", "prisma"),
("main.tf", "terraform"),
("prod.tfvars", "terraform-vars"),
+370 -18
Переглянути файл
@@ -6,11 +6,15 @@
use crate::LspManager;
use crate::server::Server;
use ide_core::{DocId, Pos, Range};
use ide_core::{CancellationToken, 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.
@@ -18,6 +22,43 @@ 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")
@@ -66,6 +107,15 @@ 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;
@@ -78,10 +128,9 @@ 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 listed = tokio::task::spawn_blocking(move || list_deprecations(&dir, &search, &modules)).await;
let Ok(Some(deprecated)) = listed else { return };
let Some(deprecated) = list_deprecations(&dir, &search, &modules, cancel).await else { return };
// The document changed meanwhile: its own save runs again.
if self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
if cancel.is_cancelled() || self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
return;
}
let items = required
@@ -157,22 +206,100 @@ struct ListedModule {
}
/// `(module, message)` of each deprecated module in `modules`; `None` when `go` failed.
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);
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() {
return None;
}
Some(parse_deprecations(&output.stdout))
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
}
fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
@@ -187,6 +314,231 @@ fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
mod tests {
use super::*;
#[test]
fn queries_cancel_only_the_superseded_document() {
let mut queries = Queries::default();
let (first, old) = queries.begin(DocId(1));
let (_, other) = queries.begin(DocId(2));
let (second, new) = queries.begin(DocId(1));
assert!(old.is_cancelled());
assert!(!other.is_cancelled());
assert!(!new.is_cancelled());
queries.finish(DocId(1), first);
assert_eq!(queries.running.len(), 2);
queries.finish(DocId(1), second);
assert_eq!(queries.running.len(), 1);
queries.cancel_all();
assert!(other.is_cancelled());
assert!(queries.running.is_empty());
}
#[test]
fn closing_one_document_does_not_cancel_another() {
let mut queries = Queries::default();
let (_, closed) = queries.begin(DocId(1));
let (_, other) = queries.begin(DocId(2));
queries.cancel(DocId(1));
assert!(closed.is_cancelled());
assert!(!other.is_cancelled());
assert_eq!(queries.running.len(), 1);
}
#[cfg(unix)]
fn shell(script: &str) -> Command {
let mut command = Command::new("sh");
command.args(["-c", script]);
command
}
#[cfg(target_os = "linux")]
async fn assert_stopped(pid: u32) {
tokio::time::timeout(Duration::from_secs(5), async {
while let Ok(stat) = std::fs::read_to_string(format!("/proc/{pid}/stat")) {
if stat.rsplit_once(") ").unwrap().1.split_whitespace().next() == Some("Z") {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
}
#[cfg(unix)]
#[tokio::test]
async fn cancelled_query_never_spawns() {
let dir = tempfile::tempdir().unwrap();
let cancel = CancellationToken::new();
cancel.cancel();
let mut command = shell("touch started");
command.current_dir(dir.path());
assert!(run_query(command, &cancel, Duration::from_secs(5)).await.is_none());
assert!(!dir.path().join("started").exists());
}
#[cfg(unix)]
#[tokio::test]
async fn queries_keep_working_directories_and_environments_separate() {
let a = tempfile::tempdir().unwrap();
let b = tempfile::tempdir().unwrap();
std::fs::write(a.path().join("value"), "directory-a").unwrap();
std::fs::write(b.path().join("value"), "directory-b").unwrap();
let mut ca = shell("printf '%s:' \"$QUERY_VALUE\"; cat value");
ca.current_dir(a.path()).env("QUERY_VALUE", "env-a");
let mut cb = shell("printf '%s:' \"$QUERY_VALUE\"; cat value");
cb.current_dir(b.path()).env("QUERY_VALUE", "env-b");
let cancel = CancellationToken::new();
let (a, b) = tokio::join!(
run_query(ca, &cancel, Duration::from_secs(5)),
run_query(cb, &cancel, Duration::from_secs(5)),
);
assert_eq!(a.unwrap(), b"env-a:directory-a");
assert_eq!(b.unwrap(), b"env-b:directory-b");
}
#[cfg(unix)]
#[tokio::test]
async fn timeout_kills_and_reaps_the_query() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("echo $$ > pid; exec sleep 2");
command.current_dir(dir.path());
let output = run_query(command, &CancellationToken::new(), Duration::from_secs(1)).await;
assert!(output.is_none());
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap().trim().parse().unwrap();
assert!(!ide_core::process::process_alive(pid));
}
#[cfg(unix)]
#[tokio::test]
async fn cancellation_kills_the_running_query_and_its_child() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("sleep 30 & echo $$ $! > pids; wait");
command.current_dir(dir.path());
let cancel = CancellationToken::new();
let token = cancel.clone();
let task = tokio::spawn(async move { run_query(command, &token, Duration::from_secs(10)).await });
let pids = dir.path().join("pids");
tokio::time::timeout(Duration::from_secs(5), async {
while !std::fs::read_to_string(&pids).is_ok_and(|s| s.split_whitespace().count() == 2) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let text = std::fs::read_to_string(pids).unwrap();
let pids: Vec<u32> = text.split_whitespace().map(|p| p.parse().unwrap()).collect();
cancel.cancel();
assert!(task.await.unwrap().is_none());
assert!(!ide_core::process::process_alive(pids[0]));
// An orphaned child may remain a zombie until the host's init reaps it.
#[cfg(target_os = "linux")]
assert_stopped(pids[1]).await;
#[cfg(not(target_os = "linux"))]
tokio::time::timeout(Duration::from_secs(5), async {
while ide_core::process::process_alive(pids[1]) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
}
#[cfg(unix)]
#[tokio::test]
async fn dropping_the_caller_still_reaps_its_query() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("sleep 30 & echo $$ $! > pid; wait");
command.current_dir(dir.path());
let task =
tokio::spawn(async move { run_query(command, &CancellationToken::new(), Duration::from_secs(10)).await });
let file = dir.path().join("pid");
tokio::time::timeout(Duration::from_secs(5), async {
while !std::fs::read_to_string(&file).is_ok_and(|s| s.split_whitespace().count() == 2) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let text = std::fs::read_to_string(file).unwrap();
let pids: Vec<u32> = text.split_whitespace().map(|p| p.parse().unwrap()).collect();
let pid = pids[0];
task.abort();
let _ = task.await;
tokio::time::timeout(Duration::from_secs(5), async {
while ide_core::process::process_alive(pid) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
#[cfg(target_os = "linux")]
assert_stopped(pids[1]).await;
#[cfg(not(target_os = "linux"))]
tokio::time::timeout(Duration::from_secs(5), async {
while ide_core::process::process_alive(pids[1]) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
}
#[cfg(target_os = "linux")]
#[tokio::test]
async fn timeout_cleans_up_a_child_holding_stdout_after_root_exit() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("sleep 30 & echo $! > pid; exit 0");
command.current_dir(dir.path());
assert!(run_query(command, &CancellationToken::new(), Duration::from_secs(1)).await.is_none());
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap();
assert_stopped(pid.trim().parse().unwrap()).await;
}
#[cfg(unix)]
#[tokio::test]
async fn output_at_the_limit_is_not_truncated() {
let output = run_query(shell("head -c 8388608 /dev/zero"), &CancellationToken::new(), Duration::from_secs(5))
.await
.unwrap();
assert_eq!(output.len() as u64, OUTPUT_LIMIT);
}
#[cfg(unix)]
#[tokio::test]
async fn oversized_output_kills_the_query() {
let dir = tempfile::tempdir().unwrap();
let mut command = shell("echo $$ > pid; head -c 8388609 /dev/zero; exec sleep 30");
command.current_dir(dir.path());
assert!(run_query(command, &CancellationToken::new(), Duration::from_secs(5)).await.is_none());
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap().trim().parse().unwrap();
assert!(!ide_core::process::process_alive(pid));
}
#[cfg(unix)]
#[tokio::test]
async fn preserves_output_from_a_nonzero_exit() {
assert_eq!(
run_query(shell("printf partial; exit 1"), &CancellationToken::new(), Duration::from_secs(5))
.await
.unwrap(),
b"partial"
);
}
#[cfg(unix)]
#[tokio::test]
async fn failed_spawn_does_not_poison_a_following_query() {
assert!(
run_query(Command::new("/no/such/go-query"), &CancellationToken::new(), Duration::from_secs(5))
.await
.is_none()
);
assert_eq!(
run_query(shell("printf ok"), &CancellationToken::new(), Duration::from_secs(5)).await.unwrap(),
b"ok"
);
}
fn at(line: u32, from: u32, to: u32) -> Range {
Range { start: Pos { line, col: from }, end: Pos { line, col: to } }
}
+5
Переглянути файл
@@ -240,6 +240,7 @@ 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.
@@ -516,6 +517,7 @@ 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()),
@@ -1393,6 +1395,7 @@ 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 };
@@ -3713,6 +3716,7 @@ 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();
}
@@ -4057,6 +4061,7 @@ 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;
+38 -2
Переглянути файл
@@ -1256,6 +1256,42 @@ 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(
@@ -1269,8 +1305,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.python_command(self.python().expect("checked"));
c.args(["-m", "pip", "install", "--disable-pip-version-check", "--no-deps", "--upgrade", "--target"])
let mut c = self.pip_command(self.python().expect("checked"), emit);
c.args(["install", "--disable-pip-version-check", "--no-deps", "--upgrade", "--target"])
.arg(&lib)
.args(["--only-binary=:all:", "--platform", "any", "--implementation", "py"])
.arg(package);
+50
Переглянути файл
@@ -895,9 +895,14 @@ 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");
@@ -935,6 +940,51 @@ 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();
+95 -3
Переглянути файл
@@ -140,9 +140,6 @@ 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") {
@@ -155,6 +152,11 @@ 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));
}
}
@@ -572,6 +574,96 @@ 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.
+83
Переглянути файл
@@ -819,3 +819,86 @@ test("keeps ordered, bulleted and task list markers unclipped inside measured ro
expect(cb.offsetFromRowLeft).toBeGreaterThanOrEqual(0);
}
});
test("indents process-run thoughts and tool calls clearly and aligns output-less tool icons", async ({ page }) => {
await openReply(page, "All checks passed.");
await page.evaluate(async (task) => {
const storePath = "/src/features/agents/store.ts";
const store = await import(storePath);
store.useAgents.setState({
tasks: new Map([[task.id, { ...task, status: "running" as const }]]),
entries: new Map([
[
task.id,
[
{ type: "thought", text: "**Checking CI Status**\n\nInspecting workflow runs." },
{
type: "tool",
id: "t1",
title: "gh pr checks 3631 --repo l0ng-ai/openidea",
kind: "execute",
status: "completed",
locations: [],
output: "All checks pending",
diffs: [],
},
{ type: "thought", text: "**Tracking Continuous Integration**\n\nWaiting for E2E." },
{
type: "tool",
id: "t2",
title: "read_bash",
kind: "other",
status: "completed",
locations: [],
output: "E2E pass",
diffs: [],
},
{
type: "tool",
id: "t3",
title: "read_bash",
kind: "other",
status: "running",
locations: [],
output: "",
diffs: [],
},
],
],
]),
});
store.openTaskInEditorLocation(task.id);
}, TASK);
const stream = page.locator("[class*='_stream_']:visible");
const summary = stream.locator("[class*='_processSummary_']").first();
await summary.click();
await expect(stream.getByText("Checking CI Status")).toBeVisible();
const layout = await stream.evaluate((root) => {
const summaryChevron = root.querySelector<SVGElement>("[class*='_processChevron_']")!.getBoundingClientRect();
const processBody = root.querySelector<HTMLElement>("[class*='_processBody_']")!.getBoundingClientRect();
const thoughtChevron = root.querySelector<SVGElement>("[class*='_thoughtChevron_']")!.getBoundingClientRect();
const toolRows = [...root.querySelectorAll<HTMLElement>("[class*='_tool_']")];
const expandableToolChevron = toolRows[0]!
.querySelector<SVGElement>("[class*='_toolChevron_']")!
.getBoundingClientRect();
const completedReadIcon = [...toolRows[1]!.querySelectorAll("svg")].at(-1)!.getBoundingClientRect();
const runningReadIcon = toolRows[2]!.querySelector("svg")!.getBoundingClientRect();
return {
summaryChevronCenter: summaryChevron.left + summaryChevron.width / 2,
guideLeft: processBody.left,
summaryToThoughtIndent: thoughtChevron.left - summaryChevron.left,
thoughtToToolIndent: expandableToolChevron.left - thoughtChevron.left,
iconLeftDiff: Math.abs(completedReadIcon.left - runningReadIcon.left),
};
});
// Guide line drops from the center of the process summary chevron.
expect(Math.abs(layout.guideLeft - layout.summaryChevronCenter)).toBeLessThanOrEqual(1.5);
// Thoughts indent clearly inside the process run, and tool calls indent under their thought step.
expect(layout.summaryToThoughtIndent).toBeGreaterThanOrEqual(20);
expect(layout.thoughtToToolIndent).toBeGreaterThanOrEqual(14);
// Output-less running tool rows align their kind icon with expandable tool rows.
expect(layout.iconLeftDiff).toBeLessThanOrEqual(1);
});
+43
Переглянути файл
@@ -0,0 +1,43 @@
import { EditorView } from "@codemirror/view";
import { commands, type InlayHint, type Range } from "../src/platform/ipc";
import { setInvokeRoute } from "../src/platform/tauriCore";
import { lspDoc } from "../src/editor/lsp/lsp";
import { inlayExtension } from "../src/editor/lsp/inlay";
import { lspTheme } from "../src/editor/lsp/theme";
const requests: { range: Range; resolve: (hints: InlayHint[]) => void }[] = [];
setInvokeRoute(() => null);
commands.lspInlayHints = async (_doc, range) =>
new Promise((resolve) => requests.push({ range, resolve: (data) => resolve({ status: "ok", data }) }));
const view = new EditorView({
parent: document.body,
doc: Array.from({ length: 2000 }, (_, i) => `let item${i} = value;`).join("\n"),
extensions: [
EditorView.theme({ "&": { height: "400px" }, ".cm-scroller": { overflow: "auto" } }),
lspTheme,
lspDoc.of({ doc: 1, path: "demo.rs", language: "rust", uiMode: "Rust", readOnly: false }),
inlayExtension(),
],
});
Object.assign(window, {
inlayTest: {
count: () => requests.length,
resolve(index: number) {
const request = requests[index]!;
request.resolve([
{
position: { line: request.range.start.line + 1, col: 4 },
label: `hint-${index}`,
kind: "type",
paddingLeft: false,
paddingRight: false,
tooltip: null,
parts: [],
},
]);
},
destroy: () => view.destroy(),
},
});
+9
Переглянути файл
@@ -0,0 +1,9 @@
<!doctype html>
<html>
<head>
<meta charset="UTF-8" />
</head>
<body>
<script type="module" src="./inlayRequests.fixture.ts"></script>
</body>
</html>
+18
Переглянути файл
@@ -0,0 +1,18 @@
import { expect, test } from "@playwright/test";
type Probe = { count(): number; resolve(index: number): void };
test("scrolling does not let an old viewport response replace current inlay hints", async ({ page }) => {
await page.goto("/e2e/inlayRequests.html");
const count = () => page.evaluate(() => (window as unknown as { inlayTest: Probe }).inlayTest.count());
await expect.poll(count).toBe(1);
await page.locator(".cm-scroller").evaluate((el) => {
el.scrollTop = 12000;
});
await expect.poll(count).toBe(2);
await page.evaluate(() => (window as unknown as { inlayTest: Probe }).inlayTest.resolve(1));
await expect(page.locator(".cm-lsp-inlay")).toHaveText("hint-1");
await page.evaluate(() => (window as unknown as { inlayTest: Probe }).inlayTest.resolve(0));
await page.waitForTimeout(500);
await expect(page.locator(".cm-lsp-inlay")).toHaveText("hint-1");
});
+6
Переглянути файл
@@ -0,0 +1,6 @@
id = "gherkin"
name = "Gherkin"
extensions = ["feature"]
line-comment = "#"
indent = { tab-size = 2, insert-spaces = true }
ui-mode = "Gherkin"
+18 -3
Переглянути файл
@@ -3862,13 +3862,18 @@ export type DataSource_Serialize = {
pluginSourceId?: string | null,
};
/** Database › Query Execution. */
/** Database settings: Query Execution and SQL Resolution Scopes. */
export type DatabaseSettings = {
/**
* A console's result sets show under the statements that produced them, in the editor,
* instead of in the Services view's result tabs.
*/
inEditorResults?: boolean,
/**
* Languages & Frameworks › SQL Resolution Scopes: the data source SQL in a file or folder
* resolves against (completion, inspections, navigation), most specific path first.
*/
resolutionScopes?: SqlResolutionScope[],
};
/** System Settings › Date Formats (Git log, Local History, blame). */
@@ -9947,7 +9952,7 @@ export type Settings_Deserialize = {
scopes?: NamedScope[],
/** Appearance & Behavior › File Colors. */
fileColors?: FileColorSettings,
/** Database › Query Execution. */
/** Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes. */
database?: DatabaseSettings,
/** Plugin settings (`[contributes.settings]`): plugin id → its values by key. */
plugins?: { [key in string]: { [key in string]: unknown } },
@@ -10019,7 +10024,7 @@ export type Settings_Serialize = {
scopes: NamedScope[],
/** Appearance & Behavior › File Colors. */
fileColors: FileColorSettings,
/** Database › Query Execution. */
/** Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes. */
database: DatabaseSettings,
/** Plugin settings (`[contributes.settings]`): plugin id → its values by key. */
plugins: { [key in string]: { [key in string]: unknown } },
@@ -10169,6 +10174,16 @@ export type SpellingSettings = {
customDictionaries?: string[],
};
/** One row of SQL Resolution Scopes. */
export type SqlResolutionScope = {
/** Project-relative file or folder, `/`-separated; empty for the whole project. */
path?: string,
/** Data source id. */
dataSource?: string,
/** Schema unqualified names resolve in; empty for the data source's default. */
schema?: string,
};
export type SqlStatement = {
/**
* UTF-16 offsets of the statement text (whitespace trimmed, `;` excluded except
+44
Переглянути файл
@@ -0,0 +1,44 @@
import { foldable } from "@codemirror/language";
import { EditorState } from "@codemirror/state";
import { describe, expect, it } from "vitest";
import { gherkinSupport } from "./gherkin";
const DOC = `@smoke
Feature: Checkout
As a shopper
Background:
Given a cart
Scenario Outline: pay with <method>
When I pay with "<method>":
| amount |
| 10 |
Then I see:
"""
Thanks
"""
Examples:
| method |
| card |
`;
describe("Gherkin", () => {
const state = EditorState.create({ doc: DOC, extensions: gherkinSupport() });
const foldAt = (lineText: string) => {
const line = state.doc.line(DOC.split("\n").findIndex((l) => l.trim() === lineText) + 1);
const r = foldable(state, line.from, line.to);
return r ? state.doc.lineAt(r.to).text.trim() : null;
};
it("folds sections, step arguments and doc strings by indentation", () => {
expect(foldAt("Feature: Checkout")).toBe("| card |");
expect(foldAt("Background:")).toBe("Given a cart");
expect(foldAt("Scenario Outline: pay with <method>")).toBe("| card |");
expect(foldAt('When I pay with "<method>":')).toBe("| 10 |");
expect(foldAt('"""')).toBe('"""');
expect(foldAt("Given a cart")).toBeNull();
expect(foldAt("@smoke")).toBeNull();
});
});
+51
Переглянути файл
@@ -0,0 +1,51 @@
/**
* 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)]);
}
+5
Переглянути файл
@@ -92,6 +92,11 @@ 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"],
+16 -5
Переглянути файл
@@ -159,7 +159,8 @@ function shownKind(kind: InlayHint["kind"]): boolean {
const inlayPlugin = ViewPlugin.fromClass(
class {
private refresh = debounce(() => void this.run(), 400);
private generation = 0;
private schedule = debounce(() => void this.run(), 400);
private unsubscribe: () => void;
private offReady: () => void;
private offSettled: () => void;
@@ -185,6 +186,10 @@ 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;
@@ -204,12 +209,17 @@ 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)));
if (view.state.doc !== state.doc) return this.refresh();
const hints = await lspRequest(
() => commands.lspInlayHints(doc.doc, offsetsToRange(state.doc, first, last)),
wanted,
);
if (!wanted()) return;
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
@@ -220,11 +230,12 @@ const inlayPlugin = ViewPlugin.fromClass(
effects: setInlays.of(inlayDecorations(view, fresh)),
});
} catch (e) {
if (isUnavailable(e)) inlayBackoff.mark(doc.doc);
if (wanted() && isUnavailable(e)) inlayBackoff.mark(doc.doc);
}
}
destroy() {
this.refresh.cancel();
this.generation++;
this.schedule.cancel();
this.unsubscribe();
this.offReady();
this.offSettled();
+184
Переглянути файл
@@ -0,0 +1,184 @@
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"]);
});
});
+31 -8
Переглянути файл
@@ -404,6 +404,13 @@
.agentName {
display: none;
}
.processBody,
.turnBody {
padding-left: var(--space-2);
}
.processBody > .thoughtEntry ~ .toolEntry {
padding-left: var(--space-3);
}
}
.messageActions {
display: inline-flex;
@@ -771,6 +778,10 @@
margin-bottom: 0;
}
.thoughtEntry,
.toolEntry {
min-width: 0;
}
.thought summary,
.toolDetails > summary {
cursor: pointer;
@@ -783,15 +794,18 @@
.thought summary {
display: flex;
align-items: center;
gap: var(--space-1);
gap: var(--space-1-5);
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 {
@@ -807,7 +821,9 @@
transform: rotate(90deg);
}
.thoughtBody {
margin-top: var(--space-2);
margin: var(--space-1-5) 0 var(--space-1) 10px;
padding-left: var(--space-3);
border-left: 1px solid var(--border);
color: var(--fg-secondary);
}
.thoughtText {
@@ -821,7 +837,7 @@
.tool {
display: flex;
align-items: center;
gap: var(--space-2);
gap: var(--space-1-5);
min-width: 0;
box-sizing: border-box;
min-height: var(--h-row);
@@ -848,6 +864,10 @@
.toolChevron {
flex: none;
}
.toolChevronSpacer {
width: 12px;
flex: none;
}
.toolDetails[open] > summary .toolChevron {
transform: rotate(90deg);
}
@@ -927,12 +947,15 @@
gap: var(--space-0-5);
max-height: calc(var(--h-row) * 16);
overflow-y: auto;
margin-top: 2px;
padding-left: 10px;
margin: 2px 0 0 10px;
padding-left: var(--space-3);
border-left: 1px solid var(--border);
}
.processBody > .thoughtEntry ~ .toolEntry {
padding-left: var(--space-4);
}
.output {
margin: 4px 0 0;
margin: 4px 0 4px 22px;
max-height: 240px;
overflow: auto;
padding: 8px 10px;
@@ -1828,8 +1851,8 @@
display: flex;
flex-direction: column;
gap: var(--space-2);
margin-top: 2px;
padding-left: 10px;
margin: 2px 0 0 10px;
padding-left: var(--space-3);
border-left: 1px solid var(--border);
}
+7 -4
Переглянути файл
@@ -1426,7 +1426,7 @@ function ThoughtEntry({
if (working && open) onDiagramDrawn();
}, [shown, working, open, onDiagramDrawn]);
return (
<div className={styles.process}>
<div className={clsx(styles.process, styles.thoughtEntry)}>
<Fold
className={clsx(styles.thought, thinking === "auto" && working && styles.thoughtLive)}
open={open}
@@ -2072,12 +2072,15 @@ const ToolEntry = memo(function ToolEntry({
);
if (!entry.output)
return (
<div className={styles.process}>
<div className={styles.tool}>{head}</div>
<div className={clsx(styles.process, styles.toolEntry)}>
<div className={styles.tool}>
<span className={styles.toolChevronSpacer} aria-hidden="true" />
{head}
</div>
</div>
);
return (
<div className={styles.process}>
<div className={clsx(styles.process, styles.toolEntry)}>
<Fold
className={styles.toolDetails}
open={liveTool(entry) || expandToolOutput}
+38 -15
Переглянути файл
@@ -11,7 +11,10 @@ const component = (name: string, options: Record<string, string>) =>
.map(([k, v]) => `<option name="${k}" value="${v}" />`)
.join("")}</component></application>`;
const editor = { fontSize: 13, customSchemes: {}, colorOverrides: {} };
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);
/** A WebStorm export, trimmed to what the import reads. */
const webstorm = {
@@ -51,8 +54,8 @@ const webstorm = {
};
describe("planJetBrainsImport", () => {
it("maps a WebStorm export to the settings it has, and lists what is left out", () => {
const plan = planJetBrainsImport(webstorm, editor);
it("maps a WebStorm export to the settings it has, and lists what is left out", async () => {
const plan = await planJetBrainsImport(webstorm, editor, fontHeight);
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]!;
@@ -62,6 +65,8 @@ 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",
@@ -83,8 +88,8 @@ describe("planJetBrainsImport", () => {
expect(plan.invalid).toEqual([]);
});
it("writes only the keys present, and derives the line height from IDEA's spacing", () => {
const plan = planJetBrainsImport(
it("writes only the keys present, and derives the line height from IDEA's spacing", async () => {
const plan = await planJetBrainsImport(
{
entries: [],
files: {
@@ -98,32 +103,50 @@ describe("planJetBrainsImport", () => {
},
},
editor,
fontHeight,
);
expect(plan.writes).toEqual([
["editor.lineHeight", 20],
// (14 + 4) × 1.5
["editor.lineHeight", 27],
["files.trimTrailingWhitespace", false],
["editor.softWrap", true],
]);
expect(plan.skipped).toEqual([]);
});
it("re-importing replaces the earlier copy of a scheme and drops its edits", () => {
const first = Object.fromEntries(planJetBrainsImport(webstorm, editor).writes);
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);
const customs = first["editor.customSchemes"] as typeof editor.customSchemes;
const [id] = Object.keys(customs);
const again = planJetBrainsImport(webstorm, {
...editor,
customSchemes: customs,
colorOverrides: { [id!]: { keyword: { bold: true } }, other: {} },
});
const again = await planJetBrainsImport(
webstorm,
{
...editor,
customSchemes: customs,
colorOverrides: { [id!]: { keyword: { bold: true } }, other: {} },
},
fontHeight,
);
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("skips colour schemes that cannot be read", () => {
const plan = planJetBrainsImport({ entries: [], files: { "colors/broken.icls": "<nope" } }, editor);
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);
expect(plan.invalid).toEqual(["broken.icls"]);
expect(plan.writes).toEqual([]);
});
+4 -1
Переглянути файл
@@ -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 = { fontSize: 13, customSchemes: {}, colorOverrides: {} };
const editor = { fontFamily: "JetBrains Mono", fontSize: 13, customSchemes: {}, colorOverrides: {} };
vi.mock("@/platform/ipc", async (original) => {
const actual = await original<typeof import("@/platform/ipc")>();
@@ -44,6 +44,8 @@ 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) => {
@@ -78,6 +80,7 @@ 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" }));
}
+44 -4
Переглянути файл
@@ -8,6 +8,7 @@
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";
@@ -28,6 +29,7 @@ export interface JetBrainsImportPlan {
}
interface EditorState {
fontFamily: string;
fontSize: number | null;
customSchemes: unknown;
colorOverrides: Record<string, unknown>;
@@ -63,7 +65,39 @@ const num = (v: string | undefined) => {
const onOff = (v: boolean) => (v ? tx("On") : tx("Off"));
export function planJetBrainsImport(bundle: JetBrainsSettings, editor: EditorState): JetBrainsImportPlan {
/** 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> {
const plan: JetBrainsImportPlan = { writes: [], rows: [], skipped: [], invalid: [] };
const add = (key: string, value: string | number | boolean | undefined, label: string, shown?: string) => {
if (value === undefined) return;
@@ -101,12 +135,18 @@ export function planJetBrainsImport(bundle: JetBrainsSettings, editor: EditorSta
}
const font = options(bundle.files["options/editor-font.xml"], "DefaultFont");
add("editor.fontFamily", font.get("FONT_FAMILY")?.trim() || undefined, tx("Font"));
const family = font.get("FONT_FAMILY")?.trim() || undefined;
add("editor.fontFamily", family, 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;
add("editor.lineHeight", spacing && base ? Math.round(base * spacing) : undefined, tx("Line height"));
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.ligatures", bool(font.get("USE_LIGATURES")), tx("Enable ligatures"));
const ed = options(bundle.files["options/editor.xml"], "EditorSettings");
@@ -174,7 +214,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 = planJetBrainsImport(bundle, editor);
const plan = await planJetBrainsImport(bundle, editor);
if (!plan.writes.length) {
notifications().notify({
level: "warning",
+2
Переглянути файл
@@ -13,6 +13,7 @@ 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("");
@@ -185,6 +186,7 @@ export function DatabaseDialogs() {
if (dialog.kind === "params") return <ParamsDialog names={dialog.names} resolve={dialog.resolve} />;
if (dialog.kind === "export")
return <ExportDialog data={dialog.data} source={dialog.source} initialFormat={dialog.format} />;
if (dialog.kind === "compareSchemas") return <SchemaCompareDialog initial={dialog.source} />;
if (dialog.kind === "history") return <HistoryDialog key={dialog.id} id={dialog.id} path={dialog.path} />;
if (dialog.kind === "import")
return (
+91
Переглянути файл
@@ -0,0 +1,91 @@
.body {
display: flex;
flex-direction: column;
gap: var(--space-2);
height: 560px;
padding: 14px;
}
.pickers {
display: flex;
align-items: center;
gap: var(--space-2);
flex-wrap: wrap;
}
.side {
display: flex;
align-items: center;
gap: var(--space-1);
}
.sideLabel {
color: var(--fg-secondary);
}
.arrow {
color: var(--fg-muted);
}
.toolbar {
display: flex;
align-items: center;
gap: var(--space-2);
}
.spacer {
flex: 1;
}
.count,
.direction {
color: var(--fg-muted);
}
.panes {
display: flex;
gap: var(--space-2);
flex: 1;
min-height: 0;
}
.tree {
display: flex;
flex-direction: column;
flex: 1.2;
min-width: 0;
border: 1px solid var(--border);
border-radius: var(--radius-control);
overflow: hidden;
}
.tree > * {
flex: 1;
min-height: 0;
}
.preview {
flex: 1;
min-width: 0;
}
.row {
display: inline-flex;
align-items: center;
gap: var(--space-1-5);
min-width: 0;
}
.name {
white-space: nowrap;
}
.detail {
overflow: hidden;
color: var(--fg-muted);
text-overflow: ellipsis;
white-space: nowrap;
}
.state {
width: 12px;
font-weight: 600;
text-align: center;
}
.added {
color: var(--vcs-added);
}
.removed {
color: var(--vcs-deleted);
}
.changed {
color: var(--vcs-modified);
}
.same {
color: var(--fg-muted);
}
+334
Переглянути файл
@@ -0,0 +1,334 @@
/**
* 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>
);
}
+37
Переглянути файл
@@ -0,0 +1,37 @@
.page {
display: flex;
flex-direction: column;
gap: var(--space-2);
color: var(--fg);
font-size: var(--fs-ui);
}
.intro,
.hint {
margin: 0;
color: var(--fg-muted);
}
.list {
display: flex;
flex-direction: column;
border: 1px solid var(--border-strong);
border-radius: var(--radius-small);
padding: var(--space-0-5) 0;
}
.head,
.row {
display: grid;
grid-template-columns: minmax(160px, 2fr) minmax(140px, 1.5fr) minmax(100px, 1fr) 24px;
align-items: center;
gap: var(--space-2);
min-height: 30px;
padding: 0 var(--space-2);
}
.head {
min-height: 24px;
color: var(--fg-muted);
border-bottom: 1px solid var(--border);
}
.project {
padding-left: var(--space-1);
font-weight: 600;
}
+144
Переглянути файл
@@ -0,0 +1,144 @@
/**
* Languages & Frameworks › SQL Resolution Scopes: which data source (and schema) SQL in a
* folder or file resolves against — completion, inspections, navigation and running
* consoles there. The project row applies wherever no folder or file row does.
*/
import { useEffect, useState } from "react";
import { call, commands, type DataSource } from "@/platform/ipc";
import { tx } from "@/platform/i18n";
import { IconButton, Input, Select, T, type SelectOption } from "@/ui";
import { useSettingsForm } from "@/workbench/contributions";
import { scopePath, validateResolutionScopes, type SqlResolutionScope } from "./resolutionScopes";
import styles from "./SqlScopesPage.module.css";
const KEY = "database.resolutionScopes";
const NONE = "";
/** An example path, the same in every language. */
const PATH_EXAMPLE = "src/main/resources/mapper";
function useDataSources(): DataSource[] | null {
const [sources, setSources] = useState<DataSource[] | null>(null);
useEffect(() => {
let stale = false;
call(commands.dbSources())
.then((list) => !stale && setSources(list))
.catch(() => !stale && setSources([]));
return () => {
stale = true;
};
}, []);
return sources;
}
export function SqlScopesPage() {
const form = useSettingsForm();
const scopes = validateResolutionScopes(form.useValue(KEY));
const sources = useDataSources();
const set = (next: SqlResolutionScope[]) => form.set(KEY, next);
const options: SelectOption[] = [
{ value: NONE, label: tx("<none>") },
...(sources ?? []).map((s) => ({ value: s.id ?? "", label: s.name ?? s.id ?? "", icon: "database" })),
];
const sourceOptions = (current: string) =>
current && !options.some((o) => o.value === current)
? [...options, { value: current, label: tx`${current} (missing)` }]
: options;
const projectIndex = scopes.findIndex((s) => !s.path);
const project = scopes[projectIndex];
const rows = scopes.map((scope, index) => ({ scope, index })).filter(({ index }) => index !== projectIndex);
const empty = (): SqlResolutionScope => ({ path: "", dataSource: NONE, schema: "" });
const patch = (index: number, p: Partial<SqlResolutionScope>) =>
set(scopes.map((s, i) => (i === index ? { ...s, ...p } : s)));
const setProject = (p: Partial<SqlResolutionScope>) =>
project ? patch(projectIndex, p) : set([{ ...empty(), ...p }, ...scopes]);
return (
<div className={styles.page}>
<p className={styles.intro}>
<T>
SQL in these folders and files resolves against the data source: completion, inspections and navigation use
its tables, and query consoles run on it unless another data source is picked in their toolbar.
</T>
</p>
<div className={styles.list} role="table" aria-label={tx("SQL Resolution Scopes")}>
<div className={styles.head} role="row">
<span role="columnheader">
<T>Path</T>
</span>
<span role="columnheader">
<T>Data Source</T>
</span>
<span role="columnheader">
<T>Schema</T>
</span>
<span />
</div>
<div className={styles.row} role="row">
<span className={styles.project} role="cell">
<T>Project</T>
</span>
<Select
value={project?.dataSource ?? NONE}
options={sourceOptions(project?.dataSource ?? NONE)}
onChange={(dataSource) => setProject({ dataSource })}
aria-label={tx("Project data source")}
/>
<Input
mono
value={project?.schema ?? ""}
placeholder={tx("Default")}
onChange={(e) => setProject({ schema: e.target.value })}
aria-label={tx("Project schema")}
/>
<span />
</div>
{rows.map(({ scope, index }) => (
<div key={index} className={styles.row} role="row">
<Input
mono
value={scope.path}
placeholder={PATH_EXAMPLE}
invalid={!scopePath(scope.path)}
onChange={(e) => patch(index, { path: e.target.value })}
aria-label={tx("Path")}
/>
<Select
value={scope.dataSource}
options={sourceOptions(scope.dataSource)}
onChange={(dataSource) => patch(index, { dataSource })}
aria-label={tx("Data source")}
/>
<Input
mono
value={scope.schema}
placeholder={tx("Default")}
onChange={(e) => patch(index, { schema: e.target.value })}
aria-label={tx("Schema")}
/>
<IconButton
icon="trash"
size="small"
title="Remove"
onClick={() => set(scopes.filter((_, i) => i !== index))}
/>
</div>
))}
</div>
<div>
<IconButton
icon="plus"
size="small"
title="Add Folder or File"
// The first row without a path is the project's: keep one ahead of the new row.
onClick={() => set([...(project ? [] : [empty()]), ...scopes, empty()])}
/>
</div>
<p className={styles.hint}>
<T>Paths are relative to the project root. The deepest folder or file that contains a file applies to it.</T>
</p>
</div>
);
}
+10 -6
Переглянути файл
@@ -57,7 +57,7 @@ import {
type SqlCandidate,
type SqlCatalog,
} from "./sql/complete";
import { sqlSupport } from "./sqlSupport";
import { WHOLE_FILE, sqlSupport, type SqlText } from "./sqlSupport";
import { snowflakeLanguage } from "./sql/snowflakeHighlight";
import {
bindConsole,
@@ -474,6 +474,8 @@ function ConsoleBar({ path, view }: { path: string; view: EditorView }) {
const pending = useDatabase((s) => !!bound && s.pendingTx.has(bound));
const databases = useDatabase((s) => s.databases);
const inEditor = useProject((s) => inEditorResults(s.settings));
// SQL resolution scopes in the settings can move the console to another data source.
useProject((s) => s.settings);
const boundId = bound ? splitTarget(bound).id : null;
const supportsTransactions = sourceById(boundId)?.driver !== "clickhouse";
const sqlServer = sourceById(boundId)?.driver === "sqlServer";
@@ -727,7 +729,7 @@ function docNode(text: string): Node {
return pre;
}
function applyCandidate(c: SqlCandidate, driver: DbDriver) {
function applyCandidate(c: SqlCandidate, driver: DbDriver, sql: SqlText) {
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;
@@ -750,7 +752,7 @@ function applyCandidate(c: SqlCandidate, driver: DbDriver) {
}
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(view.state.doc.toString(), to, driver);
const a = analyze(sql.text(view.state), to, driver);
if (a.fromInsert !== null) {
const clause = ` ${a.lowerKeywords ? "from" : "FROM"} ${c.addFrom}`;
if (a.fromInsert <= to) changes[0]!.insert += clause;
@@ -851,8 +853,10 @@ async function loadQualified(id: string, qualifier: readonly string[]): Promise<
if (schema && !useDatabase.getState().tables[tablesKey(target, schema)]) await loadTables(target, schema);
}
function completionSource(path: string): CompletionSource {
/** 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 {
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);
@@ -865,7 +869,7 @@ function completionSource(path: string): CompletionSource {
// 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 = ctx.state.doc.toString();
const doc = sql.text(ctx.state);
const analysis = placeholder
? analyze(doc.slice(0, sel.from) + doc.slice(sel.to), sel.from, driver)
: analyze(doc, ctx.pos, driver);
@@ -893,7 +897,7 @@ function completionSource(path: string): CompletionSource {
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),
apply: applyCandidate(c, driver, sql),
})),
validFor: /^[\p{L}\p{N}_$]*$/u,
};
+10
Переглянути файл
@@ -81,6 +81,8 @@ function tableTarget(arg: unknown): TableCommandTarget {
return { rows: activeCellGrid()?.selectedRows() ?? [], editor: null };
}
export { activateSettingsPages } from "./settingsPages";
export function activate(): () => void {
const disposers = [
onIdeEvent("dbSourcesChanged", () => {
@@ -122,6 +124,14 @@ export function activate(): () => void {
() => import("./console").then((m) => m.consoleExtension),
),
}),
registerEditorContribution({
id: "database.mybatis",
order: 58,
extensions: lazyEditorExtension(
(ctx) => /\.xml$/i.test(ctx.path) && !ctx.virtual,
() => import("./mybatis").then((m) => m.mapperExtension),
),
}),
// A reopened project starts with a fresh backend: forget the old one's state.
useProject.subscribe((s, prev) => {
if (s.project?.root === prev.project?.root) return;
+112
Переглянути файл
@@ -0,0 +1,112 @@
import { CompletionContext, type CompletionResult, type CompletionSource } from "@codemirror/autocomplete";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { CONTRIBUTED_HOVER, type ContributedHover } from "@/editor/api";
import { useProject } from "@/platform/project";
import { mapperExtension } from "./mybatis";
import { useDatabase } from "./store";
const published = vi.hoisted(() => new Map<string, Array<{ message: string }>>());
vi.mock("@/editor/lsp/diagnostics", () => ({
setFileDiagnostics: (path: string, _source: string, items: Array<{ message: string }>) => published.set(path, items),
}));
const PATH = "/p/src/main/resources/mapper/UserMapper.xml";
const DOC = `<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.UserMapper">
<select id="find">
select id, nam from users where id = #{id}
</select>
<select id="other">select * from orders</select>
</mapper>
`;
let view: EditorView | null = null;
beforeEach(() => {
vi.useFakeTimers();
published.clear();
useProject.setState({
project: { name: "p", root: "/p", trusted: true } as never,
settings: {
database: { resolutionScopes: [{ path: "src/main/resources/mapper", dataSource: "pg", schema: "" }] },
} as never,
});
const column = (name: string) => ({
name,
dataType: "text",
nullable: true,
primaryKey: name === "id",
hasDefault: false,
});
useDatabase.setState({
loaded: true,
sources: [
{ id: "pg", name: "Local", driver: "postgres" },
{ id: "other", name: "Other", driver: "postgres" },
],
consoles: {},
consoleSchemas: {},
completion: {
pg: {
defaultSchema: "public",
tables: [{ schema: "public", name: "users", kind: "table", columns: [column("id"), column("name")] }],
foreignKeys: [],
},
},
});
});
afterEach(() => {
view?.destroy();
view = null;
vi.useRealTimers();
});
function open(doc: string) {
view = new EditorView({
parent: document.body,
state: EditorState.create({ doc, extensions: mapperExtension({ path: PATH, language: "xml" } as never) }),
});
return view;
}
function completionAt(state: EditorState, pos: number): Promise<CompletionResult | null> {
const sources = state.languageDataAt<CompletionSource>("openideaCompletion", pos);
return Promise.resolve(sources[0]!(new CompletionContext(state, pos, true)));
}
describe("SQL in MyBatis mappers", () => {
it("reports unresolved names of the statements against the scope's data source", () => {
open(DOC);
vi.advanceTimersByTime(1000);
const messages = (published.get(PATH) ?? []).map((d) => d.message);
expect(messages.some((m) => /nam\b/.test(m))).toBe(true);
expect(messages.some((m) => /orders/.test(m))).toBe(true);
expect(messages.some((m) => /users|\bid\b/.test(m))).toBe(false);
});
it("documents tables in the statements and nothing in the XML around them", () => {
const v = open(DOC);
const hover = v.state.languageDataAt<ContributedHover>(CONTRIBUTED_HOVER, 0)[0]!;
expect(hover(v.state, DOC.indexOf("users") + 2)?.markdown).toMatch(/users/);
expect(hover(v.state, DOC.indexOf("namespace") + 2)).toBeNull();
});
it("completes columns inside a statement only", async () => {
const doc = DOC.replace("select id, nam from users", "select n from users");
const v = open(doc);
const result = await completionAt(v.state, doc.indexOf("select n") + "select n".length);
expect(result?.options.map((o) => o.label)).toContain("name");
expect(await completionAt(v.state, doc.indexOf("namespace") + 4)).toBeNull();
});
it("leaves other XML files alone", () => {
const v = open("<beans><select>not sql</select></beans>");
vi.advanceTimersByTime(1000);
expect(published.get(PATH) ?? []).toEqual([]);
expect(v.dom.querySelectorAll("[class*=ͼ]").length).toBe(0);
});
});
+123
Переглянути файл
@@ -0,0 +1,123 @@
/**
* SQL in MyBatis mapper XML: the statements of `<select>`, `<insert>`, `<update>`, `<delete>`
* and `<sql>` are highlighted as SQL and get the SQL file's tools — completion, inspections,
* Go to Declaration and Quick Documentation — against the file's data source (its SQL
* resolution scope, or the project's only data source). See `sql/mapper` for what is SQL.
*/
import { MSSQL, MySQL, PLSQL, PostgreSQL, SQLite, StandardSQL, type SQLDialect } from "@codemirror/lang-sql";
import { highlightingFor } from "@codemirror/language";
import { EditorState, RangeSetBuilder, StateEffect, type Extension, type Text } from "@codemirror/state";
import { Decoration, ViewPlugin, type DecorationSet, type EditorView, type ViewUpdate } from "@codemirror/view";
import { highlightTree } from "@lezer/highlight";
import type { EditorDocContext } from "@/editor/api";
import type { DbDriver } from "@/platform/ipc";
import { completionSource } from "./console";
import { inMapperSql, isMapper, mapperSql, type MapperSql } from "./sql/mapper";
import { sqlSupport, type SqlText } from "./sqlSupport";
import { consoleSource, sourceById, useDatabase } from "./store";
const cache = new WeakMap<Text, MapperSql | null>();
/** The file's data source (and so its dialect) changed: colour the statements again. */
const recolour = StateEffect.define<null>();
/** The SQL of the mapper in `doc` (null when it is no mapper), computed once per document version. */
function mapperOf(doc: Text): MapperSql | null {
let sql = cache.get(doc);
if (sql === undefined) {
const text = doc.toString();
sql = isMapper(text) ? mapperSql(text) : null;
cache.set(doc, sql);
}
return sql;
}
const MAPPER_SQL: SqlText = {
text: (state) => mapperOf(state.doc)?.text ?? " ".repeat(state.doc.length),
at: (state, pos) => {
const sql = mapperOf(state.doc);
return !!sql && inMapperSql(sql, pos);
},
};
function dialectOf(driver: DbDriver): SQLDialect {
switch (driver) {
case "postgres":
return PostgreSQL;
case "mysql":
return MySQL;
case "sqlite":
return SQLite;
case "sqlServer":
return MSSQL;
case "oracle":
return PLSQL;
default:
return StandardSQL;
}
}
/** Syntax colours of the statements, in the bound data source's dialect, over the XML colours. */
function sqlColours(path: string): Extension {
const build = (view: EditorView): DecorationSet => {
const sql = mapperOf(view.state.doc);
if (!sql?.segments.length) return Decoration.none;
const driver = sourceById(consoleSource(path))?.driver ?? "sqlite";
const tree = dialectOf(driver).language.parser.parse(sql.text);
const builder = new RangeSetBuilder<Decoration>();
const marks = new Map<string, Decoration>();
const style = { style: (tags: Parameters<typeof highlightingFor>[1]) => highlightingFor(view.state, tags) };
let segment = 0;
for (const { from, to } of view.visibleRanges)
highlightTree(
tree,
style,
(a, b, cls) => {
// Only the file's own SQL text: the words standing in for tags are not shown.
while (segment < sql.segments.length && sql.segments[segment]!.to <= a) segment++;
for (let i = segment; i < sql.segments.length && sql.segments[i]!.from < b; i++) {
const s = sql.segments[i]!;
const f = Math.max(a, s.from);
const t = Math.min(b, s.to);
if (f >= t) continue;
let mark = marks.get(cls);
if (!mark) marks.set(cls, (mark = Decoration.mark({ class: cls })));
builder.add(f, t, mark);
}
},
from,
to,
);
return builder.finish();
};
return ViewPlugin.fromClass(
class {
decorations: DecorationSet;
private stop: () => void;
constructor(readonly view: EditorView) {
this.decorations = build(view);
// Another data source may mean another dialect.
this.stop = useDatabase.subscribe((s, prev) => {
if (s.sources !== prev.sources || s.consoles !== prev.consoles)
queueMicrotask(() => view.dispatch({ effects: recolour.of(null) }));
});
}
update(u: ViewUpdate) {
if (u.docChanged || u.viewportChanged || u.transactions.some((tr) => tr.effects.some((e) => e.is(recolour))))
this.decorations = build(u.view);
}
destroy() {
this.stop();
}
},
{ decorations: (v) => v.decorations },
);
}
/** The SQL support of MyBatis mapper `ctx.path` (inert in other XML files). */
export function mapperExtension(ctx: EditorDocContext): Extension {
return [
sqlColours(ctx.path),
EditorState.languageData.of(() => [{ openideaCompletion: completionSource(ctx.path, MAPPER_SQL) }]),
sqlSupport(ctx.path, MAPPER_SQL),
];
}
+54
Переглянути файл
@@ -0,0 +1,54 @@
import { beforeEach, describe, expect, it } from "vitest";
import { useProject } from "@/platform/project";
import { resolutionScopeOf, validateResolutionScopes } from "./resolutionScopes";
import { bindConsole, consoleSchema, consoleSource, useDatabase } from "./store";
const scopes = validateResolutionScopes([
{ path: "", dataSource: "main", schema: "" },
{ path: "./src/main/resources/mapper/", dataSource: "orders", schema: "sales" },
{ path: "src/main/resources/mapper/legacy/Old.xml", dataSource: "legacy", schema: "" },
{ path: "src/gone", dataSource: "removed", schema: "" },
]);
describe("SQL resolution scopes", () => {
it("normalises paths and picks the deepest folder or file covering a file, else the project row", () => {
expect(scopes[1]!.path).toBe("src/main/resources/mapper");
const at = (rel: string) => resolutionScopeOf(`/p/${rel}`, "/p", scopes)?.dataSource;
expect(at("src/main/resources/mapper/UserMapper.xml")).toBe("orders");
expect(at("src/main/resources/mapper/legacy/Old.xml")).toBe("legacy");
expect(at("src/main/resources/mapper/legacy/New.xml")).toBe("orders");
// A sibling folder whose name starts the same is not inside.
expect(at("src/main/resources/mapperx/A.xml")).toBe("main");
expect(resolutionScopeOf("/elsewhere/a.sql", "/p", scopes)).toBeNull();
});
it("skips rows whose data source no longer exists", () => {
const known = (id: string) => id !== "removed";
expect(resolutionScopeOf("/p/src/gone/a.sql", "/p", scopes, known)?.dataSource).toBe("main");
});
});
describe("the data source a SQL file resolves against", () => {
beforeEach(() => {
useProject.setState({
project: { name: "p", root: "/p", trusted: true } as never,
settings: { database: { resolutionScopes: scopes } } as never,
});
useDatabase.setState({
sources: ["main", "orders", "legacy"].map((id) => ({ id, name: id, driver: "postgres" as const })),
consoles: {},
consoleSchemas: {},
completion: { orders: { defaultSchema: "public", tables: [], foreignKeys: [] } },
});
});
it("is the one picked in its toolbar, else its scope's (with the scope's schema)", () => {
const file = "/p/src/main/resources/mapper/UserMapper.xml";
expect(consoleSource(file)).toBe("orders");
expect(consoleSchema(file)).toBe("sales");
bindConsole(file, "legacy");
expect(consoleSource(file)).toBe("legacy");
bindConsole(file, null);
expect(consoleSource("/p/scratch.sql")).toBe("main");
});
});
+61
Переглянути файл
@@ -0,0 +1,61 @@
/**
* Languages & Frameworks › SQL Resolution Scopes: the data source (and schema) SQL in a
* file or folder resolves against. The most specific path wins; an empty path is the
* whole project.
*/
export interface SqlResolutionScope {
/** Project-relative file or folder, `/`-separated; empty for the whole project. */
path: string;
dataSource: string;
schema: string;
}
const str = (v: unknown) => (typeof v === "string" ? v : "");
/** Normalises a project-relative path: `/`-separated, without `./` or surrounding slashes. */
export function scopePath(path: string): string {
return path
.trim()
.replace(/\\/g, "/")
.replace(/^(\.\/)+/, "")
.replace(/^\/+|\/+$/g, "");
}
export function validateResolutionScopes(raw: unknown): SqlResolutionScope[] {
if (!Array.isArray(raw)) return [];
return raw.flatMap((r) => {
if (!r || typeof r !== "object") return [];
const o = r as Record<string, unknown>;
return [{ path: scopePath(str(o.path)), dataSource: str(o.dataSource), schema: str(o.schema).trim() }];
});
}
/** The scopes in raw settings (`database.resolutionScopes`). */
export function resolutionScopesOf(settings: unknown): SqlResolutionScope[] {
const database = (settings as { database?: { resolutionScopes?: unknown } } | null)?.database;
return validateResolutionScopes(database?.resolutionScopes);
}
/**
* The scope of `file` (absolute, under project `root`) among `scopes` whose data source
* `known` accepts: the deepest folder or the file itself, else the project's row.
*/
export function resolutionScopeOf(
file: string,
root: string,
scopes: readonly SqlResolutionScope[],
known: (dataSource: string) => boolean = () => true,
): SqlResolutionScope | null {
const base = root.replace(/\\/g, "/").replace(/\/+$/, "");
const normalized = file.replace(/\\/g, "/");
if (!base || !normalized.startsWith(`${base}/`)) return null;
const rel = normalized.slice(base.length + 1);
let best: SqlResolutionScope | null = null;
for (const scope of scopes) {
if (!scope.dataSource || !known(scope.dataSource)) continue;
const p = scope.path;
const covers = !p || rel === p || rel.startsWith(`${p}/`);
if (covers && (!best || p.length > best.path.length)) best = scope;
}
return best;
}
+90
Переглянути файл
@@ -0,0 +1,90 @@
import { describe, expect, it } from "vitest";
import type { DbColumnInfo } from "@/platform/ipc";
import { diffSchemas, differenceKeys, migrationSql, type TableSnapshot } from "./schemaCompare";
const col = (name: string, dataType: string, extra: Partial<DbColumnInfo> = {}): DbColumnInfo => ({
name,
dataType,
nullable: true,
default: null,
primaryKey: false,
...extra,
});
const users = (columns: DbColumnInfo[], indexes: TableSnapshot["indexes"] = []): TableSnapshot => ({
name: "users",
kind: "table",
columns,
indexes,
foreignKeys: [],
});
const SOURCE: TableSnapshot[] = [
users(
[
col("id", "int", { nullable: false, primaryKey: true }),
col("email", "varchar(255)", { nullable: false }),
col("age", "int", { default: "0" }),
],
[
{ name: "PRIMARY", unique: true, columns: ["id"] },
{ name: "users_email", unique: true, columns: ["email"] },
],
),
{
name: "orders",
kind: "table",
columns: [col("id", "int", { nullable: false, primaryKey: true }), col("user_id", "int")],
indexes: [
{ name: "PRIMARY", unique: true, columns: ["id"] },
{ name: "orders_user", unique: false, columns: ["user_id"] },
],
foreignKeys: [
{ schema: "app", table: "orders", columns: ["user_id"], refSchema: "app", refTable: "users", refColumns: ["id"] },
],
},
];
const TARGET: TableSnapshot[] = [
users(
[col("ID", "INT", { nullable: false, primaryKey: true }), col("email", "varchar(100)"), col("nickname", "text")],
[{ name: "PRIMARY", unique: true, columns: ["id"] }],
),
{ name: "legacy", kind: "table", columns: [col("x", "int")], indexes: [], foreignKeys: [] },
];
describe("Compare Structure", () => {
const diffs = diffSchemas(SOURCE, TARGET);
it("lists added, removed and changed tables with their column and index differences", () => {
expect(diffs.map((d) => `${d.name}:${d.state}`)).toEqual(["legacy:removed", "orders:added", "users:changed"]);
const u = diffs.find((d) => d.name === "users")!;
expect(u.columns.map((c) => `${c.name}:${c.state}:${c.changes.join("+")}`)).toEqual([
"id:same:",
"email:changed:type+nullable",
"age:added:",
"nickname:removed:",
]);
expect(u.indexes.map((i) => `${i.name}:${i.state}`)).toEqual(["PRIMARY:same", "users_email:added"]);
});
it("writes the migration of the selected differences for the target's dialect", () => {
const all = migrationSql("mysql", "app", diffs, differenceKeys(diffs));
expect(all).toBe(
[
"drop table app.legacy;",
"create table app.orders\n(\n id int not null,\n user_id int,\n primary key (id)\n);",
"alter table app.users change column email email varchar(255) not null;",
"alter table app.users add column age int default 0;",
"alter table app.users drop column nickname;",
"create index orders_user on app.orders (user_id);",
"alter table app.orders add foreign key (user_id) references app.users (id);",
"create unique index users_email on app.users (email);",
"",
].join("\n"),
);
// Only what is picked; identical items never produce SQL.
const some = migrationSql("postgres", "public", diffs, new Set(["c:users.age", "c:users.id", "t:legacy"]));
expect(some).toBe("drop table public.legacy;\nalter table public.users add column age int default 0;\n");
});
});
+234
Переглянути файл
@@ -0,0 +1,234 @@
/**
* 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` : "";
}
+16
Переглянути файл
@@ -0,0 +1,16 @@
import { lazyComponent } from "@/ui";
import { registerSettingsPage } from "@/workbench/contributions";
/** Settings › Languages & Frameworks › SQL Resolution Scopes (also used by the Settings window). */
export function activateSettingsPages(): () => void {
return registerSettingsPage({
id: "languages.sqlResolutionScopes",
title: "SQL Resolution Scopes",
group: "Languages & Frameworks",
order: 404.5,
projectScope: true,
defaultScope: "project",
keywords: ["sql", "data source", "database", "schema", "mybatis", "mapper", "resolve", "dialect"],
component: lazyComponent(() => import("./SqlScopesPage").then((m) => m.SqlScopesPage)),
});
}
+55
Переглянути файл
@@ -0,0 +1,55 @@
import { describe, expect, it } from "vitest";
import { inMapperSql, isMapper, mapperSql } from "./mapper";
const MAPPER = `<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.UserMapper">
<resultMap id="user" type="User"><id column="id" property="id"/></resultMap>
<select id="find" resultMap="user">
select id, name from users
<where>
<if test="name != null">and name = #{name}</if>
<if test="ids != null">and id in
<foreach collection="ids" item="i" open="(" separator="," close=")">#{i}</foreach>
</if>
and age &gt; 18
</where>
</select>
<insert id="add">
<selectKey keyProperty="id" resultType="int">select last_insert_id()</selectKey>
insert into users (name) values (#{name})
</insert>
<!-- <select id="old">select * from old</select> -->
<update id="rename"><![CDATA[update users set name = #{name} where age < 3]]></update>
<update id="touch">update users <set><if test="a">name = #{a},</if></set> where id = #{id}</update>
</mapper>`;
describe("MyBatis mapper SQL", () => {
it("recognises mapper files", () => {
expect(isMapper(MAPPER)).toBe(true);
expect(isMapper("<beans><bean id='a'/></beans>")).toBe(false);
});
it("keeps the statements' SQL at its offsets and blanks the rest", () => {
const { text } = mapperSql(MAPPER);
expect(text).toHaveLength(MAPPER.length);
expect(text.split("\n")).toHaveLength(MAPPER.split("\n").length);
const sql = text.replace(/\s+/g, " ").trim();
expect(sql).toBe(
"select id, name from users where name = ? and id in ( ? ) and age > 18 ; " +
"insert into users (name) values (? ) ; update users set name = ? where age < 3 ; " +
"update users set name = ? where id = ? ;",
);
const at = MAPPER.indexOf("users");
expect(text.slice(at, at + 5)).toBe("users");
});
it("knows which offsets are SQL", () => {
const sql = mapperSql(MAPPER);
expect(inMapperSql(sql, MAPPER.indexOf("from users") + 2)).toBe(true);
expect(inMapperSql(sql, MAPPER.indexOf("resultMap="))).toBe(false);
expect(inMapperSql(sql, MAPPER.indexOf('test="name'))).toBe(false);
expect(inMapperSql(sql, MAPPER.indexOf("last_insert_id"))).toBe(false);
expect(inMapperSql(sql, MAPPER.indexOf("from old"))).toBe(false);
});
});
+154
Переглянути файл
@@ -0,0 +1,154 @@
/**
* 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);
}
+41 -14
Переглянути файл
@@ -20,6 +20,7 @@ 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). */
@@ -38,18 +39,29 @@ function sourceOf(path: string): { id: string | null; driver: DbDriver; model: D
};
}
function resolver(path: string, state: EditorState): SqlResolver {
/**
* 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 {
const { driver, model } = sourceOf(path);
return new SqlResolver(state.doc.toString(), driver, model);
return new SqlResolver(sql.text(state), driver, model);
}
/** Unresolved tables / columns / aliases as error diagnostics, re-checked after edits and schema loads. */
function inspections(path: string): Extension {
function inspections(path: string, sql: SqlText): 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).problems() : [];
const problems = sourceOf(path).model ? resolver(path, view.state, sql).problems() : [];
setFileDiagnostics(
path,
INSPECTIONS,
@@ -69,9 +81,18 @@ function inspections(path: string): 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)
if (
s.completion !== prev.completion ||
s.consoles !== prev.consoles ||
s.consoleSchemas !== prev.consoleSchemas ||
s.sources !== prev.sources
)
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();
@@ -79,16 +100,20 @@ function inspections(path: string): Extension {
destroy: () => {
clearTimeout(timer);
unsubscribe();
unsubscribeSettings();
setFileDiagnostics(path, INSPECTIONS, []);
},
};
});
}
function definition(path: string): ContributedDefinition {
function definition(path: string, sql: SqlText): ContributedDefinition {
return (view, pos) => {
const r = resolver(path, view.state).resolveAt(pos);
if (sql.at && !sql.at(view.state, pos)) return false;
const r = resolver(path, view.state, sql).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);
@@ -172,9 +197,10 @@ function symbolDoc(sym: SqlSymbol, model: DbCompletion | null): string | null {
}
}
function hover(path: string): ContributedHover {
function hover(path: string, sql: SqlText): ContributedHover {
return (state, pos) => {
const r = resolver(path, state).resolveAt(pos);
if (sql.at && !sql.at(state, pos)) return null;
const r = resolver(path, state, sql).resolveAt(pos);
const markdown = r?.symbol ? symbolDoc(r.symbol, sourceOf(path).model) : null;
return r && markdown ? { from: r.from, to: r.to, markdown } : null;
};
@@ -184,11 +210,12 @@ function formatter(path: string): ContributedFormatter {
return (state, range) => formatSql(state.doc.toString(), sourceOf(path).driver, range);
}
export function sqlSupport(path: string): Extension {
/** 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 {
const data = {
[CONTRIBUTED_DEFINITION]: definition(path),
[CONTRIBUTED_HOVER]: hover(path),
[CONTRIBUTED_FORMAT]: formatter(path),
[CONTRIBUTED_DEFINITION]: definition(path, sql),
[CONTRIBUTED_HOVER]: hover(path, sql),
...(sql === WHOLE_FILE ? { [CONTRIBUTED_FORMAT]: formatter(path) } : {}),
};
return [inspections(path), EditorState.languageData.of(() => [data])];
return [inspections(path, sql), EditorState.languageData.of(() => [data])];
}
+44 -3
Переглянути файл
@@ -56,6 +56,8 @@ 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";
@@ -142,7 +144,9 @@ 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 };
| { 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 };
/** The schemas and tables of a data source's databases, as far as introspection has read them. */
export interface SourceCatalog {
@@ -708,6 +712,25 @@ 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);
@@ -884,7 +907,10 @@ export function bindConsole(path: string, id: string | null) {
export function consoleSchema(path: string): string {
const s = useDatabase.getState();
const id = consoleSource(path);
return activeSchema(s.consoleSchemas[path], id ? s.completion[id]?.defaultSchema : undefined);
// A scope's schema applies while the console is on that scope's data source.
const scope = s.consoles[path] ? null : scopeOf(path);
const picked = s.consoleSchemas[path] ?? (scope && scope.dataSource === id ? scope.schema : undefined);
return activeSchema(picked || undefined, id ? s.completion[id]?.defaultSchema : undefined);
}
/** Sets (or clears, for `null`) the console's active schema and remembers it per console file. */
@@ -902,11 +928,26 @@ export function setConsoleSchema(path: string, schema: string | null) {
});
}
/** The data source a console / SQL file runs on: its binding, else the only data source. */
/** The SQL resolution scope of file `path` (Languages & Frameworks › SQL Resolution Scopes), if any. */
function scopeOf(path: string): SqlResolutionScope | null {
const { project, settings } = useProject.getState();
if (!project) return null;
const sources = useDatabase.getState().sources;
return resolutionScopeOf(path, project.root, resolutionScopesOf(settings), (id) =>
sources.some((x) => x.id === splitTarget(id).id),
);
}
/**
* The data source a console / SQL file runs on and resolves against: the one picked in its
* toolbar, else its SQL resolution scope's, else the only data source.
*/
export function consoleSource(path: string): string | null {
const s = useDatabase.getState();
const bound = s.consoles[path];
if (bound && s.sources.some((x) => x.id === splitTarget(bound).id)) return bound;
const scope = scopeOf(path);
if (scope) return scope.dataSource;
return s.sources.length === 1 ? (s.sources[0]!.id ?? null) : null;
}
+16
Переглянути файл
@@ -389,6 +389,22 @@ export function registerDatabaseTreeActions(): () => void {
if (schema !== null) openDialog({ kind: "modifyTable", id, schema, table: null });
},
}),
tree({
id: "db.compareSchemas",
title: "Compare Structure…",
description: "Compare the tables of two schemas and write the migration SQL from one to the other",
icon: "diff-side-by-side",
keywords: ["schema compare", "diff", "migration", "compare schemas", "structure"],
run: ({ arg }) => {
const n = nodeFrom(arg);
const id = n && nodeTarget(n);
const schema = n && "schema" in n && typeof n.schema === "string" ? n.schema : null;
openDialog({
kind: "compareSchemas",
source: id ? { id, schema: schema ?? (driverOf(id) === "sqlite" ? "main" : "") } : null,
});
},
}),
tree({
id: "db.newColumn",
title: "Column",
+2
Переглянути файл
@@ -117,6 +117,7 @@ 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…" }),
];
@@ -142,6 +143,7 @@ export function nodeMenu(n: DbNode | null): MenuItem[] {
navigation(),
sep,
sqlScripts(n, false),
...(n.kind === "schema" ? [act("db.compareSchemas", n)] : []),
...(n.kind === "schema" ? [sep, drop] : []),
];
case "table":
-1
Переглянути файл
@@ -83,7 +83,6 @@ 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;
+2 -1
Переглянути файл
@@ -48,7 +48,7 @@ import { activate as analysis } from "./analysis";
import { activate as services } from "./services";
import { activate as github, activateSettingsPages as githubPages } from "./github";
import { activate as httpClient } from "./http-client";
import { activate as database } from "./database";
import { activate as database, activateSettingsPages as databasePages } from "./database";
import { activate as graphql } from "./graphql";
import { activate as deployment, activateDeploymentWindow } from "./deployment";
import { activate as agents, activateSettingsPages as agentsPages } from "./agents";
@@ -188,6 +188,7 @@ export function activateSettingsWindowFeatures(parent: string): () => void {
["vim", vimPages],
["vcs", vcsPages],
["github", githubPages],
["database", databasePages],
];
return activateAll("settings pages", pages);
}
+3 -2
Переглянути файл
@@ -152,10 +152,11 @@ function PageHost({
const spec = page ? builtinSpec(page.id) : undefined;
const projectScope = !!(spec?.projectScope ?? page?.projectScope) && hasProject && !newProjects;
const scopeKey = spec?.scopeGroup ?? pageId;
const chosen = useSettingsDialog((s) => s.scopes[scopeKey]) ?? spec?.defaultScope;
const defaultScope = spec?.defaultScope ?? page?.defaultScope;
const chosen = useSettingsDialog((s) => s.scopes[scopeKey]) ?? defaultScope;
const scope: Scope = projectScope && chosen === "project" ? "project" : "global";
// Where a project value is the norm, say what the global one is for.
const globalNote = newProjects || (projectScope && scope === "global" && spec?.defaultScope === "project");
const globalNote = newProjects || (projectScope && scope === "global" && defaultScope === "project");
const ctx = useMemo(() => ({ pageId, scope }), [pageId, scope]);
const form = useSettingsFormFor(pageId, scope);
const focus = useSettingsDialog((s) => s.focus);
+13 -3
Переглянути файл
@@ -64,7 +64,7 @@ export interface ValidSettings extends WorkflowSettings {
scopes: NamedScope[];
fileColors: FileColorSettings;
/** Database › Query Execution. */
database: { inEditorResults: boolean };
database: { inEditorResults: boolean; resolutionScopes: Array<{ path: string; dataSource: string; schema: string }> };
general: {
reopenLastProject: boolean;
confirmExit: boolean;
@@ -167,7 +167,7 @@ export const DEFAULT_SETTINGS: ValidSettings = {
plugins: {},
scopes: [],
fileColors: DEFAULT_FILE_COLORS,
database: { inEditorResults: false },
database: { inEditorResults: false, resolutionScopes: [] },
general: {
reopenLastProject: true,
confirmExit: true,
@@ -343,7 +343,17 @@ export function validateSettings(raw: Settings | unknown): ValidSettings {
plugins: Object.fromEntries(Object.entries(obj(root.plugins)).map(([id, values]) => [id, obj(values)])),
scopes: validateScopes(root.scopes),
fileColors: validateFileColors(root.fileColors),
database: { inEditorResults: bool(obj(root.database).inEditorResults, d.database.inEditorResults) },
database: {
inEditorResults: bool(obj(root.database).inEditorResults, d.database.inEditorResults),
resolutionScopes: (Array.isArray(obj(root.database).resolutionScopes)
? (obj(root.database).resolutionScopes as unknown[])
: []
).map((r) => ({
path: str(obj(r).path, ""),
dataSource: str(obj(r).dataSource, ""),
schema: str(obj(r).schema, ""),
})),
},
general: {
...validateGeneralExtras(g),
reopenLastProject: bool(g.reopenLastProject, d.general.reopenLastProject),
+32 -1
Переглянути файл
@@ -1971,5 +1971,36 @@
"Edit File Colors…": "Edit File Colors…",
"Enable system notifications": "Enable system notifications",
"In-Editor Results": "In-Editor Results",
"Show query results in the editor, under the statements that produced them": "Show query results in the editor, under the statements that produced them"
"Show query results in the editor, under the statements that produced them": "Show query results in the editor, under the statements that produced them",
"SQL Resolution Scopes": "SQL Resolution Scopes",
"SQL in these folders and files resolves against the data source: completion, inspections and navigation use its tables, and query consoles run on it unless another data source is picked in their toolbar.": "SQL in these folders and files resolves against the data source: completion, inspections and navigation use its tables, and query consoles run on it unless another data source is picked in their toolbar.",
"Project data source": "Project data source",
"Project schema": "Project schema",
"Add Folder or File": "Add Folder or File",
"Paths are relative to the project root. The deepest folder or file that contains a file applies to it.": "Paths are relative to the project root. The deepest folder or file that contains a file applies to it.",
"{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"
}
+28 -1
Переглянути файл
@@ -8363,5 +8363,32 @@
"Edit File Colors…": "编辑文件颜色…",
"Enable system notifications": "启用系统通知",
"In-Editor Results": "编辑器内结果",
"Show query results in the editor, under the statements that produced them": "在编辑器中、产生结果的语句下方显示查询结果"
"Show query results in the editor, under the statements that produced them": "在编辑器中、产生结果的语句下方显示查询结果",
"SQL Resolution Scopes": "SQL 解析作用域",
"SQL in these folders and files resolves against the data source: completion, inspections and navigation use its tables, and query consoles run on it unless another data source is picked in their toolbar.": "这些文件夹和文件中的 SQL 按所选数据源解析:补全、检查和导航使用它的表;查询控制台也在它上面执行,除非在控制台工具栏中另选了数据源。",
"Project data source": "项目数据源",
"Project schema": "项目架构",
"Add Folder or File": "添加文件夹或文件",
"Paths are relative to the project root. The deepest folder or file that contains a file applies to it.": "路径相对于项目根目录。对某个文件生效的是包含它的最深一级文件夹或该文件本身。",
"{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": "索引"
}
+2
Переглянути файл
@@ -179,6 +179,7 @@ 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",
@@ -1148,6 +1149,7 @@ 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",
+3
Переглянути файл
@@ -0,0 +1,3 @@
<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

+3
Переглянути файл
@@ -0,0 +1,3 @@
<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

+2
Переглянути файл
@@ -1091,6 +1091,8 @@ export interface SettingsPageContribution {
component?: ComponentType;
/** The page edits settings that a project can override (Global / This project switch). */
projectScope?: boolean;
/** The scope the switch starts on (default: global). */
defaultScope?: "global" | "project";
}
/**