дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-21 00:50:47 +02:00
Порівняти коміти
60
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
55cb9f11f7 | ||
|
|
1000ef0fa0 | ||
|
|
654da3e1ef | ||
|
|
ba6ccaf9b2 | ||
|
|
3ec631f0c0 | ||
|
|
f64796607c | ||
|
|
5baaf5b7de | ||
|
|
95f88f6ffb | ||
|
|
06b7c3a826 | ||
|
|
e9335f032d | ||
|
|
d09fdc8c7e | ||
|
|
54e69973c8 | ||
|
|
91d37aa4bf | ||
|
|
e149ba2ab3 | ||
|
|
fc6de7d0e4 | ||
|
|
76ef8c9b05 | ||
|
|
0344553652 | ||
|
|
cf15013b49 | ||
|
|
eb985cda28 | ||
|
|
212ee03d71 | ||
|
|
b721fe09db | ||
|
|
6ffb4c22f0 | ||
|
|
dc38b0b081 | ||
|
|
3cbc9d7f75 | ||
|
|
2ec2a6c262 | ||
|
|
11dca3ab42 | ||
|
|
f9044dcc00 | ||
|
|
a7d7293b2f | ||
|
|
a5280c50f7 | ||
|
|
dd0578979a | ||
|
|
e96b0483ac | ||
|
|
608b292510 | ||
|
|
dd6d83fd2c | ||
|
|
b89febd61f | ||
|
|
99ca421a0e | ||
|
|
e6fd000bb7 | ||
|
|
9e2e229a56 | ||
|
|
60564f4b33 | ||
|
|
db1fff2f6a | ||
|
|
1c09fbe28a | ||
|
|
834fac89b4 | ||
|
|
844e290729 | ||
|
|
a1ab5b6c29 | ||
|
|
9797598864 | ||
|
|
21a8856dfd | ||
|
|
9c523bba36 | ||
|
|
8f3e20cdf8 | ||
|
|
affee5452d | ||
|
|
4149c1b5d7 | ||
|
|
52010b95b1 | ||
|
|
9e530a9024 | ||
|
|
aebc7f7f99 | ||
|
|
1586738468 | ||
|
|
7ec5080047 | ||
|
|
06d7487913 | ||
|
|
e676138956 | ||
|
|
1a1ea14b9c | ||
|
|
5c0917b849 | ||
|
|
19f2c0ef5d | ||
|
|
8c696b8fe7 |
No files matched your search
Створено
+18
@@ -4156,6 +4156,8 @@ dependencies = [
|
||||
"ide-vcs",
|
||||
"ide-vfs",
|
||||
"parking_lot",
|
||||
"rustix",
|
||||
"semver",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"specta",
|
||||
@@ -4357,6 +4359,20 @@ dependencies = [
|
||||
"which",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-drag-out"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"gtk",
|
||||
"objc2 0.6.5",
|
||||
"objc2-app-kit 0.3.2",
|
||||
"objc2-foundation 0.3.2",
|
||||
"raw-window-handle",
|
||||
"tempfile",
|
||||
"windows",
|
||||
"windows-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-extension"
|
||||
version = "0.1.49"
|
||||
@@ -4511,6 +4527,7 @@ dependencies = [
|
||||
name = "ide-http"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"hyper-util",
|
||||
"ide-core",
|
||||
"ide-vfs",
|
||||
"parking_lot",
|
||||
@@ -6697,6 +6714,7 @@ dependencies = [
|
||||
"ide-dap",
|
||||
"ide-db",
|
||||
"ide-docker",
|
||||
"ide-drag-out",
|
||||
"ide-extension",
|
||||
"ide-fonts",
|
||||
"ide-github",
|
||||
|
||||
@@ -38,6 +38,7 @@ ide-web = { path = "crates/ide-web" }
|
||||
ide-spell = { path = "crates/ide-spell" }
|
||||
ide-agent = { path = "crates/ide-agent" }
|
||||
ide-clipboard = { path = "crates/ide-clipboard" }
|
||||
ide-drag-out = { path = "crates/ide-drag-out" }
|
||||
ide-fonts = { path = "crates/ide-fonts" }
|
||||
ide-ssh = { path = "crates/ide-ssh" }
|
||||
ide-remote = { path = "crates/ide-remote" }
|
||||
|
||||
@@ -25,6 +25,10 @@ dunce.workspace = true
|
||||
uuid.workspace = true
|
||||
tempfile.workspace = true
|
||||
which = "8"
|
||||
semver = "1"
|
||||
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
rustix = { version = "1", features = ["fs"] }
|
||||
|
||||
[dev-dependencies]
|
||||
tokio = { workspace = true, features = ["test-util"] }
|
||||
@@ -0,0 +1,395 @@
|
||||
//! Checks and updates only the global npm installation selected by the agent launcher.
|
||||
use crate::{AgentManager, AgentSource, provider};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, error::ErrorKind};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
use specta::Type;
|
||||
use std::{
|
||||
fs, io,
|
||||
path::{Path, PathBuf},
|
||||
process::Command,
|
||||
};
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
pub struct AgentCliOffer {
|
||||
pub current: String,
|
||||
pub latest: String,
|
||||
pub prefix: PathBuf,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "status", rename_all = "camelCase")]
|
||||
pub enum AgentCliUpdateResult {
|
||||
Available(AgentCliOffer),
|
||||
Permission(AgentCliOffer),
|
||||
Current { current: String },
|
||||
Channel { current: String },
|
||||
Updated { current: String },
|
||||
Unmanaged,
|
||||
Error { code: String },
|
||||
}
|
||||
|
||||
pub(crate) fn package(id: &str) -> Option<&'static str> {
|
||||
Some(match id {
|
||||
"claude" => "@anthropic-ai/claude-code",
|
||||
"codex" => "@openai/codex",
|
||||
"gemini" => "@google/gemini-cli",
|
||||
"opencode" => "opencode-ai",
|
||||
"copilot" => "@github/copilot",
|
||||
"qwen" => "@qwen-code/qwen-code",
|
||||
"auggie" => "@augmentcode/auggie",
|
||||
"qoder" => "@qoder-ai/qodercli",
|
||||
"omp" => "@oh-my-pi/pi-coding-agent",
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
impl AgentManager {
|
||||
pub fn cli_update(
|
||||
&self,
|
||||
id: &str,
|
||||
offer: Option<&AgentCliOffer>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
let spec = self.shared.spec(id).ok_or_else(|| IdeError::invalid(format!("unknown agent {id}")))?;
|
||||
let (Some(pkg), Some(builtin)) = (package(id), provider::builtin_spec(id)) else {
|
||||
return Ok(AgentCliUpdateResult::Unmanaged);
|
||||
};
|
||||
if spec.source != AgentSource::Builtin {
|
||||
return Ok(AgentCliUpdateResult::Unmanaged);
|
||||
}
|
||||
let Ok(npm) = which::which("npm") else { return Ok(AgentCliUpdateResult::Unmanaged) };
|
||||
let program = spec.resolve_for_launch(&self.shared.paths.project_root).command;
|
||||
match maintain(&npm, Path::new(&program), &builtin.command, pkg, offer, cancel) {
|
||||
Err(e) if e.kind == ErrorKind::Unavailable => Ok(AgentCliUpdateResult::Error { code: e.message }),
|
||||
result => result,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct Installation {
|
||||
modules: PathBuf,
|
||||
folder: PathBuf,
|
||||
link: PathBuf,
|
||||
}
|
||||
|
||||
impl Installation {
|
||||
fn at(prefix: &Path, pkg: &str, bin: &str) -> Self {
|
||||
let modules = prefix.join(if cfg!(windows) { "node_modules" } else { "lib/node_modules" });
|
||||
let link = if cfg!(windows) { prefix.join(format!("{bin}.cmd")) } else { prefix.join("bin").join(bin) };
|
||||
Self { folder: modules.join(pkg), modules, link }
|
||||
}
|
||||
|
||||
fn version(&self, program: &Path, pkg: &str, bin: &str) -> IdeResult<Option<String>> {
|
||||
if !program.is_absolute() || !self.folder.try_exists()? || !self.link.try_exists()? || !program.try_exists()? {
|
||||
return Ok(None);
|
||||
}
|
||||
let folder = dunce::canonicalize(&self.folder)?;
|
||||
if fs::symlink_metadata(&self.folder)?.is_symlink()
|
||||
|| dunce::canonicalize(program)? != dunce::canonicalize(&self.link)?
|
||||
{
|
||||
return Ok(None);
|
||||
}
|
||||
let manifest = self.folder.join("package.json");
|
||||
if !manifest.try_exists()? {
|
||||
return Ok(None);
|
||||
}
|
||||
let manifest: Value = serde_json::from_slice(&fs::read(manifest)?)
|
||||
.map_err(|_| IdeError::invalid("Invalid npm package manifest"))?;
|
||||
let entry = manifest["bin"].as_str().or_else(|| manifest["bin"][bin].as_str());
|
||||
let Some(entry) = entry.filter(|_| manifest["name"] == pkg) else { return Ok(None) };
|
||||
let Some(version) = manifest["version"].as_str() else {
|
||||
return Err(IdeError::invalid("Missing npm package version"));
|
||||
};
|
||||
let entry = folder.join(entry);
|
||||
if !entry.try_exists()? {
|
||||
return Ok(None);
|
||||
}
|
||||
let entry = dunce::canonicalize(entry)?;
|
||||
if !entry.starts_with(&folder) {
|
||||
return Ok(None);
|
||||
}
|
||||
#[cfg(unix)]
|
||||
let owns = fs::symlink_metadata(&self.link)?.is_symlink() && dunce::canonicalize(&self.link)? == entry;
|
||||
#[cfg(windows)]
|
||||
let owns = {
|
||||
let prefix = dunce::canonicalize(self.link.parent().unwrap())?;
|
||||
let Ok(target) = entry.strip_prefix(prefix) else { return Ok(None) };
|
||||
let needle = format!("%dp0%\\{}\"", target.display()).to_lowercase();
|
||||
fs::read_to_string(&self.link)?.replace('/', "\\").to_lowercase().contains(&needle)
|
||||
};
|
||||
Ok(owns.then(|| version.to_owned()))
|
||||
}
|
||||
|
||||
fn writable(&self) -> io::Result<bool> {
|
||||
for dir in [&*self.folder, self.folder.parent().unwrap(), &self.modules, self.link.parent().unwrap()] {
|
||||
#[cfg(unix)]
|
||||
let access: io::Result<()> =
|
||||
rustix::fs::accessat(rustix::fs::CWD, dir, rustix::fs::Access::WRITE_OK, rustix::fs::AtFlags::empty())
|
||||
.map_err(Into::into);
|
||||
#[cfg(windows)]
|
||||
let access = tempfile::tempfile_in(dir).map(drop);
|
||||
match access {
|
||||
Err(e) if matches!(e.kind(), io::ErrorKind::PermissionDenied | io::ErrorKind::ReadOnlyFilesystem) => {
|
||||
return Ok(false);
|
||||
}
|
||||
other => other?,
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
fn stable(version: &str) -> Option<semver::Version> {
|
||||
semver::Version::parse(version).ok().filter(|v| v.pre.is_empty() && v.build.is_empty())
|
||||
}
|
||||
|
||||
fn maintain(
|
||||
npm: &Path,
|
||||
program: &Path,
|
||||
bin: &str,
|
||||
pkg: &str,
|
||||
approved: Option<&AgentCliOffer>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
use AgentCliUpdateResult::*;
|
||||
let run = |args: &[&str]| {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let mut cmd = Command::new(npm);
|
||||
cmd.args(args)
|
||||
.current_dir(npm.parent().unwrap())
|
||||
.env("NPM_CONFIG_UPDATE_NOTIFIER", "false")
|
||||
.env("NPM_CONFIG_LOGLEVEL", "error");
|
||||
ide_tools::run_streamed(cmd, cancel, &|_| {}).map_err(|e| {
|
||||
if e.kind == ErrorKind::Cancelled {
|
||||
return e;
|
||||
}
|
||||
// npm diagnostics can contain private registry URLs; expose only known codes.
|
||||
let code = e
|
||||
.message
|
||||
.split(|c: char| !c.is_ascii_alphanumeric() && c != '_')
|
||||
.find(|w| {
|
||||
matches!(
|
||||
*w,
|
||||
"EACCES"
|
||||
| "EPERM"
|
||||
| "EROFS"
|
||||
| "ENOTFOUND"
|
||||
| "EAI_AGAIN"
|
||||
| "ETIMEDOUT"
|
||||
| "E404"
|
||||
| "E401"
|
||||
| "E403"
|
||||
)
|
||||
})
|
||||
.unwrap_or("npm");
|
||||
IdeError::unavailable(code)
|
||||
})
|
||||
};
|
||||
let output = run(&["prefix", "-g"])?;
|
||||
let prefix = Path::new(output.trim_end());
|
||||
if !prefix.is_absolute() {
|
||||
return Err(IdeError::invalid("Invalid npm global prefix"));
|
||||
}
|
||||
let installation = Installation::at(prefix, pkg, bin);
|
||||
let Some(current) = installation.version(program, pkg, bin)? else { return Ok(Unmanaged) };
|
||||
let latest: String = serde_json::from_str(&run(&["view", &format!("{pkg}@latest"), "version", "--json"])?)
|
||||
.map_err(|_| IdeError::invalid("Invalid npm version response"))?;
|
||||
let (Some(before), Some(after)) = (stable(¤t), stable(&latest)) else {
|
||||
return Ok(Channel { current });
|
||||
};
|
||||
if before >= after {
|
||||
return Ok(Current { current });
|
||||
}
|
||||
let offer = AgentCliOffer { current, latest, prefix: prefix.to_owned() };
|
||||
if !installation.writable()? {
|
||||
return Ok(Permission(offer));
|
||||
}
|
||||
if approved != Some(&offer) {
|
||||
return Ok(Available(offer));
|
||||
}
|
||||
run(&[
|
||||
"install",
|
||||
"-g",
|
||||
"--prefix",
|
||||
prefix.to_str().unwrap(),
|
||||
"--no-audit",
|
||||
"--no-fund",
|
||||
&format!("{pkg}@{}", offer.latest),
|
||||
])?;
|
||||
if installation.version(program, pkg, bin)?.as_ref() != Some(&offer.latest) {
|
||||
return Err(IdeError::invalid("npm installation verification failed"));
|
||||
}
|
||||
Ok(Updated { current: offer.latest })
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
use tempfile::TempDir;
|
||||
|
||||
const PKG: &str = "@anthropic-ai/claude-code";
|
||||
|
||||
struct Fixture {
|
||||
root: TempDir,
|
||||
install: Installation,
|
||||
}
|
||||
|
||||
impl Fixture {
|
||||
fn new() -> Self {
|
||||
let root = tempfile::Builder::new().prefix("全局 prefix ").tempdir().unwrap();
|
||||
let install = Installation::at(root.path(), PKG, "claude");
|
||||
fs::create_dir_all(&install.folder).unwrap();
|
||||
fs::create_dir_all(install.link.parent().unwrap()).unwrap();
|
||||
fs::write(install.folder.join("entry.js"), "").unwrap();
|
||||
#[cfg(unix)]
|
||||
std::os::unix::fs::symlink(install.folder.join("entry.js"), &install.link).unwrap();
|
||||
#[cfg(windows)]
|
||||
fs::write(&install.link, r#"@"%dp0%\node_modules\@anthropic-ai\claude-code\entry.js""#).unwrap();
|
||||
let fixture = Self { root, install };
|
||||
fixture.manifest(PKG, "2.1.9");
|
||||
fixture
|
||||
}
|
||||
|
||||
fn manifest(&self, name: &str, version: &str) {
|
||||
fs::write(
|
||||
self.install.folder.join("package.json"),
|
||||
json!({"name":name,"version":version,"bin":{"claude":"entry.js"}}).to_string(),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
fn version(&self) -> Option<String> {
|
||||
self.install.version(&self.install.link, PKG, "claude").unwrap()
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn npm(&self, script: &str) -> PathBuf {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let path = self.root.path().join("npm");
|
||||
fs::write(&path, format!("#!/bin/sh\nset -eu\n{script}\n")).unwrap();
|
||||
fs::set_permissions(&path, fs::Permissions::from_mode(0o755)).unwrap();
|
||||
path
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn requires_the_selected_install_and_its_exact_package_entry() {
|
||||
let f = Fixture::new();
|
||||
assert_eq!(f.version().as_deref(), Some("2.1.9"));
|
||||
let other = f.root.path().join("other");
|
||||
fs::write(&other, "").unwrap();
|
||||
assert_eq!(f.install.version(&other, PKG, "claude").unwrap(), None);
|
||||
f.manifest("other-package", "2.1.9");
|
||||
assert_eq!(f.version(), None);
|
||||
f.manifest(PKG, "2.1.9");
|
||||
fs::remove_file(&f.install.link).unwrap();
|
||||
#[cfg(unix)]
|
||||
std::os::unix::fs::symlink(&other, &f.install.link).unwrap();
|
||||
#[cfg(windows)]
|
||||
fs::write(&f.install.link, r#"@"%dp0%\other""#).unwrap();
|
||||
assert_eq!(f.version(), None);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
const NPM: &str = r#"case "$1" in
|
||||
prefix) pwd -P ;;
|
||||
view) cat latest ;;
|
||||
install)
|
||||
test "$2" = "-g" && test "$3" = "--prefix" && test "$4" = "$(pwd -P)"
|
||||
test "$7" = "@anthropic-ai/[email protected]"
|
||||
cp updated.json "$4/lib/node_modules/@anthropic-ai/claude-code/package.json"
|
||||
touch installed ;;
|
||||
*) exit 2 ;;
|
||||
esac"#;
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn installs_only_the_confirmed_offer_and_rechecks_ownership() {
|
||||
use AgentCliUpdateResult::*;
|
||||
let f = Fixture::new();
|
||||
let npm = f.npm(NPM);
|
||||
let cancel = CancellationToken::new();
|
||||
let run =
|
||||
|offer: Option<&AgentCliOffer>| maintain(&npm, &f.install.link, "claude", PKG, offer, &cancel).unwrap();
|
||||
let latest = f.root.path().join("latest");
|
||||
fs::write(&latest, r#""2.1.12""#).unwrap();
|
||||
let Available(offer) = run(None) else { panic!("expected an offer") };
|
||||
for different in [
|
||||
AgentCliOffer { prefix: PathBuf::from("/other"), ..offer.clone() },
|
||||
AgentCliOffer { current: "2.0.0".into(), ..offer.clone() },
|
||||
] {
|
||||
assert_eq!(run(Some(&different)), Available(offer.clone()));
|
||||
}
|
||||
fs::write(&latest, r#""2.2.0""#).unwrap();
|
||||
assert!(matches!(run(Some(&offer)), Available(new) if new.latest == "2.2.0"));
|
||||
fs::write(&latest, r#""2.0.0""#).unwrap();
|
||||
assert!(matches!(run(Some(&offer)), Current { .. }));
|
||||
fs::write(&latest, r#""2.2.0-beta.1""#).unwrap();
|
||||
assert!(matches!(run(Some(&offer)), Channel { .. }));
|
||||
fs::write(&latest, r#""2.1.12""#).unwrap();
|
||||
f.manifest("other-package", "2.1.9");
|
||||
assert_eq!(run(Some(&offer)), Unmanaged);
|
||||
assert!(!f.root.path().join("installed").exists());
|
||||
f.manifest(PKG, "2.1.12");
|
||||
fs::copy(f.install.folder.join("package.json"), f.root.path().join("updated.json")).unwrap();
|
||||
f.manifest(PKG, "2.1.9");
|
||||
assert_eq!(run(Some(&offer)), Updated { current: "2.1.12".into() });
|
||||
assert!(f.root.path().join("installed").exists());
|
||||
assert_eq!(run(None), Current { current: "2.1.12".into() });
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn permission_failure_never_starts_an_install() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let f = Fixture::new();
|
||||
let npm = f.npm(NPM);
|
||||
fs::write(f.root.path().join("latest"), r#""2.1.12""#).unwrap();
|
||||
let run = |offer: Option<&AgentCliOffer>| {
|
||||
maintain(&npm, &f.install.link, "claude", PKG, offer, &CancellationToken::new()).unwrap()
|
||||
};
|
||||
let AgentCliUpdateResult::Available(offer) = run(None) else { panic!("expected an offer") };
|
||||
fs::set_permissions(&f.install.folder, fs::Permissions::from_mode(0o555)).unwrap();
|
||||
// root can write even when no mode bit grants write permission.
|
||||
if tempfile::tempfile_in(&f.install.folder).is_err() {
|
||||
assert_eq!(run(Some(&offer)), AgentCliUpdateResult::Permission(offer));
|
||||
}
|
||||
fs::set_permissions(&f.install.folder, fs::Permissions::from_mode(0o755)).unwrap();
|
||||
assert!(!f.root.path().join("installed").exists());
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn cancellation_stops_a_running_npm_process() {
|
||||
use std::time::{Duration, Instant};
|
||||
let f = Fixture::new();
|
||||
let npm = f.npm(
|
||||
r#"case "$1" in
|
||||
prefix) pwd -P ;;
|
||||
view) echo '"2.1.12"' ;;
|
||||
install) touch started; exec sleep 30 ;;
|
||||
esac"#,
|
||||
);
|
||||
let cancel = CancellationToken::new();
|
||||
let AgentCliUpdateResult::Available(offer) =
|
||||
maintain(&npm, &f.install.link, "claude", PKG, None, &cancel).unwrap()
|
||||
else {
|
||||
panic!("expected an offer")
|
||||
};
|
||||
let started = f.root.path().join("started");
|
||||
std::thread::scope(|s| {
|
||||
let op = s.spawn(|| maintain(&npm, &f.install.link, "claude", PKG, Some(&offer), &cancel));
|
||||
let deadline = Instant::now() + Duration::from_secs(5);
|
||||
while !started.exists() && Instant::now() < deadline {
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
}
|
||||
cancel.cancel();
|
||||
assert!(started.exists());
|
||||
assert_eq!(op.join().unwrap().unwrap_err().kind, ErrorKind::Cancelled);
|
||||
});
|
||||
assert_eq!(f.version().as_deref(), Some("2.1.9"));
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@
|
||||
mod acp;
|
||||
mod async_questions;
|
||||
mod catalogs;
|
||||
mod cli_update;
|
||||
mod config;
|
||||
mod conversation;
|
||||
mod elicitation;
|
||||
@@ -27,6 +28,7 @@ mod timeline;
|
||||
mod worktree;
|
||||
|
||||
pub use catalogs::AgentCatalogs;
|
||||
pub use cli_update::{AgentCliOffer, AgentCliUpdateResult};
|
||||
pub use external::ExternalSession;
|
||||
pub use model::*;
|
||||
|
||||
@@ -141,7 +143,7 @@ struct Shared {
|
||||
paths: AgentPaths,
|
||||
runtime: tokio::runtime::Handle,
|
||||
connector: Connector,
|
||||
sink: RwLock<Option<AgentSink>>,
|
||||
sinks: RwLock<HashMap<String, AgentSink>>,
|
||||
security: RwLock<Option<SecurityHook>>,
|
||||
new_task_approvals: RwLock<Option<NewTaskApprovalsHook>>,
|
||||
known: Arc<Mutex<HashMap<String, Known>>>,
|
||||
@@ -213,10 +215,12 @@ impl Shared {
|
||||
}
|
||||
|
||||
fn emit(&self, event: AgentEvent) {
|
||||
let sink = self.sink.read().clone();
|
||||
if let Some(sink) = sink {
|
||||
sink(event);
|
||||
let mut sinks: Vec<_> = self.sinks.read().values().cloned().collect();
|
||||
let Some(last) = sinks.pop() else { return };
|
||||
for sink in sinks {
|
||||
sink(event.clone());
|
||||
}
|
||||
last(event);
|
||||
}
|
||||
|
||||
/// The MCP servers passed to a session, and the names of the ones off for it.
|
||||
@@ -561,7 +565,7 @@ impl AgentManager {
|
||||
paths,
|
||||
runtime,
|
||||
connector,
|
||||
sink: RwLock::new(None),
|
||||
sinks: RwLock::new(HashMap::new()),
|
||||
security: RwLock::new(None),
|
||||
new_task_approvals: RwLock::new(None),
|
||||
known,
|
||||
@@ -604,12 +608,22 @@ impl AgentManager {
|
||||
|
||||
/// Routes events to `sink` (replacing the previous subscriber); returns every task.
|
||||
pub fn subscribe(&self, sink: AgentSink) -> Vec<AgentTask> {
|
||||
*self.shared.sink.write() = Some(sink);
|
||||
self.subscribe_as("", sink)
|
||||
}
|
||||
|
||||
/// Routes events to `sink` too, replacing only the sink `subscriber` (a view of the project) had.
|
||||
pub fn subscribe_as(&self, subscriber: &str, sink: AgentSink) -> Vec<AgentTask> {
|
||||
self.shared.sinks.write().insert(subscriber.to_owned(), sink);
|
||||
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().snapshot()).collect();
|
||||
tasks.sort_by(|a, b| b.updated_ms.total_cmp(&a.updated_ms));
|
||||
tasks
|
||||
}
|
||||
|
||||
/// A closed view releases its sink, never the task or its agent process.
|
||||
pub fn unsubscribe(&self, subscriber: &str) {
|
||||
self.shared.sinks.write().remove(subscriber);
|
||||
}
|
||||
|
||||
/// Sets the callback used to read the active command execution security policy.
|
||||
pub fn set_security_hook(&self, hook: SecurityHook) {
|
||||
*self.shared.security.write() = Some(hook);
|
||||
@@ -2000,7 +2014,7 @@ impl AgentManager {
|
||||
// What arrived after the last save (a subagent's late updates).
|
||||
task.persist();
|
||||
}
|
||||
*self.shared.sink.write() = None;
|
||||
self.shared.sinks.write().clear();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -614,6 +614,9 @@ pub struct AgentProvider {
|
||||
pub command_read_only_reason: Option<AgentCommandReadOnlyReason>,
|
||||
/// Whether the command was found (on `PATH`).
|
||||
pub installed: bool,
|
||||
/// The built-in command can be owned by a global npm package.
|
||||
#[serde(default)]
|
||||
pub can_check_cli_update: bool,
|
||||
/// Environment variables it starts with (from its agent file).
|
||||
pub env: BTreeMap<String, String>,
|
||||
/// Settings (models, modes…) the agent offered last time it ran; empty before its first session.
|
||||
|
||||
@@ -373,6 +373,7 @@ pub(crate) fn describe(spec: &ProviderSpec) -> AgentProvider {
|
||||
command_editable: reason.is_none(),
|
||||
command_read_only_reason: reason,
|
||||
installed: installed(&spec.command),
|
||||
can_check_cli_update: spec.source == AgentSource::Builtin && crate::cli_update::package(&spec.id).is_some(),
|
||||
env: spec.env.iter().cloned().collect(),
|
||||
config: vec![],
|
||||
thought_levels: BTreeMap::new(),
|
||||
|
||||
@@ -452,6 +452,35 @@ fn manager(dir: &Path, agent: Arc<FakeAgent>) -> AgentManager {
|
||||
manager_at(dir, &dir.join("models.json"), agent)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn subscribers_do_not_replace_or_close_each_other() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let main = Arc::new(Mutex::new(Vec::new()));
|
||||
let child = Arc::new(Mutex::new(Vec::new()));
|
||||
let subscribe = |window: &str, events: &Arc<Mutex<Vec<AgentEvent>>>| {
|
||||
let events = events.clone();
|
||||
mgr.subscribe_as(window, Arc::new(move |event| events.lock().push(event)));
|
||||
};
|
||||
subscribe("main", &main);
|
||||
subscribe("editor-main-1", &child);
|
||||
mgr.shared.emit(AgentEvent::Providers);
|
||||
assert_eq!(main.lock().len(), 1);
|
||||
assert_eq!(child.lock().len(), 1);
|
||||
// A reloaded webview replaces only its own old channel.
|
||||
let reloaded = Arc::new(Mutex::new(Vec::new()));
|
||||
subscribe("editor-main-1", &reloaded);
|
||||
mgr.shared.emit(AgentEvent::Providers);
|
||||
assert_eq!(main.lock().len(), 2);
|
||||
assert_eq!(child.lock().len(), 1);
|
||||
assert_eq!(reloaded.lock().len(), 1);
|
||||
mgr.unsubscribe("editor-main-1");
|
||||
mgr.shared.emit(AgentEvent::Providers);
|
||||
assert_eq!(main.lock().len(), 3);
|
||||
assert_eq!(reloaded.lock().len(), 1);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
fn manager_at(dir: &Path, models_file: &Path, agent: Arc<FakeAgent>) -> AgentManager {
|
||||
// These tests speak to FakeAgent, never an installed CLI, including after a provider reload.
|
||||
let agents = dir.join("agents");
|
||||
|
||||
@@ -197,6 +197,7 @@ pub enum ImportsOnPaste {
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct FoldingSettings {
|
||||
pub show_outline: bool,
|
||||
pub outline_visibility: FoldingOutlineVisibility,
|
||||
pub file_header: bool,
|
||||
pub imports: bool,
|
||||
pub doc_comments: bool,
|
||||
@@ -204,10 +205,24 @@ pub struct FoldingSettings {
|
||||
|
||||
impl Default for FoldingSettings {
|
||||
fn default() -> Self {
|
||||
Self { show_outline: true, file_header: true, imports: true, doc_comments: false }
|
||||
Self {
|
||||
show_outline: true,
|
||||
outline_visibility: FoldingOutlineVisibility::Hover,
|
||||
file_header: true,
|
||||
imports: true,
|
||||
doc_comments: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum FoldingOutlineVisibility {
|
||||
#[default]
|
||||
Hover,
|
||||
Always,
|
||||
}
|
||||
|
||||
/// Editor › General › Editor Tabs.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
@@ -543,3 +558,24 @@ mod auto_import_tests {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod folding_tests {
|
||||
use super::{FoldingOutlineVisibility, FoldingSettings};
|
||||
|
||||
#[test]
|
||||
fn folding_outline_defaults_to_hover_for_existing_settings() {
|
||||
let settings: FoldingSettings = serde_json::from_str(r#"{"showOutline":false}"#).unwrap();
|
||||
assert!(!settings.show_outline);
|
||||
assert_eq!(settings.outline_visibility, FoldingOutlineVisibility::Hover);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn folding_outline_visibility_round_trips() {
|
||||
for mode in ["hover", "always"] {
|
||||
let json = serde_json::json!({ "outlineVisibility": mode });
|
||||
let settings: FoldingSettings = serde_json::from_value(json).unwrap();
|
||||
assert_eq!(serde_json::to_value(settings).unwrap()["outlineVisibility"], mode);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -15,6 +15,7 @@ pub mod inspection_settings;
|
||||
pub mod ipc_path;
|
||||
pub mod java_runtime;
|
||||
pub mod jsonc;
|
||||
pub mod memory;
|
||||
pub mod output_encoding;
|
||||
pub mod platform;
|
||||
pub mod process;
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
//! Returning freed heap pages to the OS.
|
||||
|
||||
/// Hands pages the allocator has freed but kept back to the OS. Call after a burst of
|
||||
/// short-lived allocations (a full index scan); until then they still count towards the
|
||||
/// process's memory footprint.
|
||||
pub fn release_free_pages() {
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
unsafe extern "C" {
|
||||
fn malloc_zone_pressure_relief(zone: *mut std::ffi::c_void, goal: usize) -> usize;
|
||||
}
|
||||
// SAFETY: a null zone covers every zone; a zero goal releases as much as possible.
|
||||
unsafe { malloc_zone_pressure_relief(std::ptr::null_mut(), 0) };
|
||||
}
|
||||
#[cfg(all(target_os = "linux", target_env = "gnu"))]
|
||||
// SAFETY: malloc_trim only returns free memory to the OS.
|
||||
unsafe {
|
||||
libc::malloc_trim(0);
|
||||
}
|
||||
}
|
||||
@@ -11,6 +11,8 @@ use std::collections::BTreeMap;
|
||||
pub struct VcsSettings {
|
||||
/// Colour folders that contain changed files (project tree, tabs).
|
||||
pub show_dirty_directories: bool,
|
||||
/// Diffs the user opens show in an editor tab; off, in a separate window.
|
||||
pub diff_as_editor_tab: bool,
|
||||
/// Stop file history (Show History) after `history_limit` commits.
|
||||
pub limit_history: bool,
|
||||
pub history_limit: u32,
|
||||
@@ -55,6 +57,7 @@ impl Default for VcsSettings {
|
||||
Self {
|
||||
// IDEA's VcsConfiguration.SHOW_DIRTY_RECURSIVELY is off by default.
|
||||
show_dirty_directories: false,
|
||||
diff_as_editor_tab: true,
|
||||
limit_history: true,
|
||||
history_limit: 1000,
|
||||
git: GitSettings::default(),
|
||||
|
||||
@@ -145,30 +145,38 @@ impl ClickhousePool {
|
||||
let cancel = CancellationToken::new();
|
||||
let initialize = async {
|
||||
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
|
||||
if !rejects_driver_setting(&error) {
|
||||
let Some(setting) = rejected_driver_setting(&error) else {
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
if !use_http_session {
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Retry only the connection probe. Keep relying on the server for write protection
|
||||
// only after verifying strict read-only mode in this same session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// Start the proof in a fresh session: the rejected probe may have left
|
||||
// its id on another replica without applying the configured database.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
if setting == "readonly" {
|
||||
return Err(error);
|
||||
}
|
||||
if !source.read_only {
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; enable Read-only for independent queries on a strict read-only server",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Every request still sends readonly=1, regardless of which node answers.
|
||||
pool.0.session.lock().await.strict_read_only = true;
|
||||
pool.execute("SELECT 1", 1, &cancel).await?;
|
||||
} else {
|
||||
// Only rely on the server's write protection after proving strict read-only
|
||||
// in this same named session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// The rejected probe may have opened a session on a different node.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
// The HTTP database parameter applies to one request. A named session needs
|
||||
@@ -236,7 +244,7 @@ impl ClickhousePool {
|
||||
if !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
|
||||
request = request.query(&[("database", &self.0.database)]);
|
||||
}
|
||||
if self.0.read_only && !session.strict_read_only {
|
||||
if self.0.read_only && (session.id.is_none() || !session.strict_read_only) {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
request
|
||||
@@ -324,7 +332,7 @@ impl ClickhousePool {
|
||||
result
|
||||
}
|
||||
None => {
|
||||
let killed = self.kill(&client, &query_id).await;
|
||||
let killed = self.kill(&client, &query_id, &session).await;
|
||||
match killed {
|
||||
Ok(()) => Err(IdeError::cancelled()),
|
||||
Err(error) => Err(IdeError::new(
|
||||
@@ -336,15 +344,16 @@ impl ClickhousePool {
|
||||
}
|
||||
}
|
||||
|
||||
async fn kill(&self, client: &Client, query_id: &str) -> IdeResult<()> {
|
||||
let response = client
|
||||
async fn kill(&self, client: &Client, query_id: &str, session: &Session) -> IdeResult<()> {
|
||||
let mut request = client
|
||||
.post(self.0.endpoint.clone())
|
||||
.basic_auth(&self.0.user, Some(&self.0.password))
|
||||
.timeout(Duration::from_secs(3))
|
||||
.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC"))
|
||||
.send()
|
||||
.await
|
||||
.map_err(http_error)?;
|
||||
.timeout(Duration::from_secs(3));
|
||||
if self.0.read_only && session.id.is_none() {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
let response =
|
||||
request.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")).send().await.map_err(http_error)?;
|
||||
let status = response.status();
|
||||
let code = response
|
||||
.headers()
|
||||
@@ -551,13 +560,14 @@ fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
|
||||
.map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
|
||||
}
|
||||
|
||||
fn rejects_driver_setting(error: &IdeError) -> bool {
|
||||
fn rejected_driver_setting(error: &IdeError) -> Option<&str> {
|
||||
error
|
||||
.message
|
||||
.split_once(": ")
|
||||
.and_then(|(_, detail)| detail.strip_prefix("Code: 164. DB::Exception: Cannot modify '"))
|
||||
.and_then(|detail| detail.split_once("' setting in readonly mode"))
|
||||
.is_some_and(|(name, _)| {
|
||||
.map(|(name, _)| name)
|
||||
.filter(|&name| {
|
||||
matches!(
|
||||
name,
|
||||
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
|
||||
@@ -953,19 +963,77 @@ mod tests {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
|
||||
for read_only in [false, true] {
|
||||
let (port, requests) = server(vec![(
|
||||
async fn strict_stateless_connections_keep_readonly_on_every_request() {
|
||||
let denied = "Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)";
|
||||
let (port, requests) = server(vec![
|
||||
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", denied),
|
||||
("200 OK", "", ONE),
|
||||
(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot execute query in readonly mode. (READONLY)",
|
||||
),
|
||||
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[0]\n[1]\n[2]\n"),
|
||||
])
|
||||
.await;
|
||||
let source = DataSource {
|
||||
database: "fixture_database".into(),
|
||||
read_only: true,
|
||||
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let write = "CREATE TABLE fixture_table (n UInt8) ENGINE=Memory";
|
||||
assert!(pool.execute(write, 1, &cancel).await.unwrap_err().message.contains("Code: 164"));
|
||||
let sql = "SELECT number AS n FROM numbers(3) LIMIT 3";
|
||||
let result = pool.execute(sql, 1, &cancel).await.unwrap();
|
||||
assert_eq!(result.rows, vec![vec![Some("0".into())]]);
|
||||
assert!(result.has_more);
|
||||
let requests = requests.await.unwrap();
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[1].ends_with("SELECT 1"));
|
||||
assert!(requests[2].ends_with(write));
|
||||
assert!(requests[3].ends_with(sql));
|
||||
for (index, request) in requests.iter().enumerate() {
|
||||
let url = request_url(request);
|
||||
for name in ["session_id", "session_check", "session_timeout", "use_http_session"] {
|
||||
assert_eq!(query_value(&url, name), None, "{name}");
|
||||
}
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "database").as_deref(), Some("fixture_database"));
|
||||
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
|
||||
assert_eq!(query_value(&url, "max_result_rows").as_deref(), (index == 0).then_some("2"));
|
||||
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), (index == 0).then_some("break"));
|
||||
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), (index == 0).then_some("1"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_connections_require_readonly_and_only_relax_driver_result_settings() {
|
||||
for (read_only, detail, body) in [
|
||||
(
|
||||
false,
|
||||
"enable Read-only",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
|
||||
)])
|
||||
.await;
|
||||
),
|
||||
(
|
||||
true,
|
||||
"Cannot modify 'readonly'",
|
||||
"Code: 164. DB::Exception: Cannot modify 'readonly' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
(
|
||||
true,
|
||||
"Cannot modify 'max_threads'",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_threads' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
] {
|
||||
let (port, requests) =
|
||||
server(vec![("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", body)]).await;
|
||||
let source =
|
||||
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
|
||||
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
|
||||
assert!(error.message.contains("use_http_session=false requires per-request"));
|
||||
assert!(error.message.contains(detail), "{}", error.message);
|
||||
let requests = requests.await.unwrap();
|
||||
assert_eq!(requests.len(), 1);
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
@@ -1041,7 +1109,7 @@ mod tests {
|
||||
let error = IdeError::invalid(format!(
|
||||
"ClickHouse HTTP 500: Code: {code}. DB::Exception: Cannot modify '{setting}' setting in readonly mode. (READONLY)"
|
||||
));
|
||||
assert_eq!(rejects_driver_setting(&error), expected, "{setting}");
|
||||
assert_eq!(rejected_driver_setting(&error).is_some(), expected, "{setting}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1084,37 +1152,45 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn cancellation_sends_kill_outside_the_busy_session() {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let (started, received) = tokio::sync::oneshot::channel();
|
||||
let server = tokio::spawn(async move {
|
||||
let (mut health, _) = listener.accept().await.unwrap();
|
||||
read_request(&mut health).await;
|
||||
reply(&mut health, "200 OK", "", ONE).await;
|
||||
drop(health);
|
||||
let (mut query, _) = listener.accept().await.unwrap();
|
||||
let request = read_request(&mut query).await;
|
||||
started.send(()).unwrap();
|
||||
let (mut kill, _) = tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
|
||||
let kill_request = read_request(&mut kill).await;
|
||||
reply(&mut kill, "200 OK", "", "").await;
|
||||
(request, kill_request)
|
||||
});
|
||||
let pool = Pool::connect(&source(port), None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
|
||||
let cancelled = async {
|
||||
received.await.unwrap();
|
||||
cancel.cancel();
|
||||
};
|
||||
let (result, ()) = tokio::join!(query, cancelled);
|
||||
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
|
||||
let (query, kill) = server.await.unwrap();
|
||||
let target = query.lines().next().unwrap().split_whitespace().nth(1).unwrap();
|
||||
let url = Url::parse(&format!("http://localhost{target}")).unwrap();
|
||||
let query_id = url.query_pairs().find(|(k, _)| k == "query_id").unwrap().1.into_owned();
|
||||
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
|
||||
assert!(!kill.contains("session_id="));
|
||||
for stateless in [false, true] {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let (started, received) = tokio::sync::oneshot::channel();
|
||||
let server = tokio::spawn(async move {
|
||||
let (mut health, _) = listener.accept().await.unwrap();
|
||||
read_request(&mut health).await;
|
||||
reply(&mut health, "200 OK", "", ONE).await;
|
||||
drop(health);
|
||||
let (mut query, _) = listener.accept().await.unwrap();
|
||||
let request = read_request(&mut query).await;
|
||||
started.send(()).unwrap();
|
||||
let (mut kill, _) =
|
||||
tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
|
||||
let kill_request = read_request(&mut kill).await;
|
||||
reply(&mut kill, "200 OK", "", "").await;
|
||||
(request, kill_request)
|
||||
});
|
||||
let source = DataSource {
|
||||
read_only: true,
|
||||
properties: vec![property("use_http_session", if stateless { "false" } else { "true" })],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
|
||||
let cancelled = async {
|
||||
received.await.unwrap();
|
||||
cancel.cancel();
|
||||
};
|
||||
let (result, ()) = tokio::join!(query, cancelled);
|
||||
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
|
||||
let (query, kill) = server.await.unwrap();
|
||||
let query_id = query_value(&request_url(&query), "query_id").unwrap();
|
||||
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
|
||||
let url = request_url(&kill);
|
||||
assert_eq!(query_value(&url, "session_id"), None);
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), stateless.then_some("1"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
@@ -303,7 +303,9 @@ async fn read_frame(output: &mut (impl AsyncRead + Unpin)) -> IdeResult<Vec<u8>>
|
||||
const CANCEL_GRACE: Duration = Duration::from_secs(3);
|
||||
|
||||
fn cancel_timeout() -> IdeError {
|
||||
IdeError::invalid("The JDBC driver did not stop in time. The session was closed. Reconnect to continue.")
|
||||
IdeError::invalid(
|
||||
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect.",
|
||||
)
|
||||
}
|
||||
|
||||
async fn exchange(
|
||||
@@ -602,7 +604,13 @@ impl DbManager {
|
||||
pub(crate) async fn jdbc_completion(&self, id: &str, pool: &JdbcPool) -> IdeResult<crate::CompletionModel> {
|
||||
let mut tables = vec![];
|
||||
let mut column_count = 0;
|
||||
let schemas = self.schemas(id).await?;
|
||||
// Read the schemas the source's Schemas tab picks, like the database tree does. It also
|
||||
// keeps large instances usable: an Oracle server exposes dozens of system schemas, and
|
||||
// dumping the columns of all of them takes minutes, during which the bridge (a single
|
||||
// Java process that runs one command at a time) executes none of the user's statements.
|
||||
let introspection = self.source(id)?.introspection;
|
||||
let schemas: Vec<String> =
|
||||
self.schemas(id).await?.into_iter().filter(|s| introspection.shows_schema(s)).collect();
|
||||
for schema in &schemas {
|
||||
// Columns of the whole namespace in one call; a driver that refuses it still completes tables.
|
||||
let mut columns = if column_count < crate::MAX_META_ROWS {
|
||||
|
||||
@@ -124,6 +124,45 @@ impl Default for DbIntrospection {
|
||||
}
|
||||
}
|
||||
|
||||
impl DbIntrospection {
|
||||
/// Whether the tree shows this schema: every one with `all_schemas`, otherwise it has to
|
||||
/// match one of the `schemas` patterns. The completion model uses the same test, so it
|
||||
/// offers exactly the tables the tree lists (and does not read the ones it never shows).
|
||||
pub fn shows_schema(&self, name: &str) -> bool {
|
||||
self.all_schemas
|
||||
|| self.schemas.iter().map(|p| p.trim()).filter(|p| !p.is_empty()).any(|p| schema_matches(p, name))
|
||||
}
|
||||
}
|
||||
|
||||
/// `*` matches any run of characters, `?` a single one; a pattern without wildcards matches the
|
||||
/// name as typed (the dialog fills names from the list the server returned, so case is settled).
|
||||
fn schema_matches(pattern: &str, name: &str) -> bool {
|
||||
if !pattern.contains('*') && !pattern.contains('?') {
|
||||
return pattern == name;
|
||||
}
|
||||
let p: Vec<char> = pattern.chars().collect();
|
||||
let n: Vec<char> = name.chars().collect();
|
||||
let (mut pi, mut ni) = (0, 0);
|
||||
// Position of the last `*` and how much of the name it has already swallowed.
|
||||
let mut star: Option<(usize, usize)> = None;
|
||||
while ni < n.len() {
|
||||
if pi < p.len() && (p[pi] == '?' || p[pi] == n[ni]) {
|
||||
pi += 1;
|
||||
ni += 1;
|
||||
} else if pi < p.len() && p[pi] == '*' {
|
||||
star = Some((pi, ni));
|
||||
pi += 1;
|
||||
} else if let Some((at, taken)) = star {
|
||||
pi = at + 1;
|
||||
ni = taken + 1;
|
||||
star = Some((at, taken + 1));
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
p[pi..].iter().all(|&c| c == '*')
|
||||
}
|
||||
|
||||
/// Advanced tab: a driver property. PostgreSQL: run-time parameters (and
|
||||
/// `application_name`); MySQL: session variables (and `charset`, `collation`);
|
||||
/// SQLite: pragmas. See [`crate::conn`].
|
||||
@@ -765,4 +804,24 @@ mod tests {
|
||||
assert_eq!(r.snowflake().auth, DbSnowflakeAuth::Browser);
|
||||
assert_eq!(scheme_driver("snowflake"), Some(DbDriver::Snowflake));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn introspection_shows_only_the_picked_schemas() {
|
||||
let mut i = DbIntrospection::default();
|
||||
assert!(i.shows_schema("SYS"), "the default reads every schema");
|
||||
|
||||
i.all_schemas = false;
|
||||
assert!(!i.shows_schema("SYS"), "nothing picked: the tree lists nothing either");
|
||||
|
||||
i.schemas = vec!["XMCB".into(), " APP_* ".into()];
|
||||
assert!(i.shows_schema("XMCB"));
|
||||
assert!(i.shows_schema("APP_INFO"));
|
||||
assert!(!i.shows_schema("APP"), "`*` needs the text that follows it");
|
||||
assert!(!i.shows_schema("SYS"));
|
||||
assert!(!i.shows_schema("xmcb"), "patterns match the names the server returned");
|
||||
|
||||
i.schemas = vec!["?".into()];
|
||||
assert!(i.shows_schema("A"));
|
||||
assert!(!i.shows_schema("AB"));
|
||||
}
|
||||
}
|
||||
@@ -210,9 +210,13 @@ async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
|
||||
})
|
||||
.await
|
||||
.expect("driver cancellation must be bounded");
|
||||
assert!(result.unwrap_err().message.contains("Reconnect"));
|
||||
db.disconnect("test").await;
|
||||
assert_eq!(db.execute("test", "after reconnect", 1, &normal).await?.affected, Some(1.0));
|
||||
assert_eq!(
|
||||
result.unwrap_err().message,
|
||||
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect."
|
||||
);
|
||||
assert!(db.connected().is_empty());
|
||||
assert_eq!(db.execute("test", "after cancellation", 1, &normal).await?.affected, Some(1.0));
|
||||
assert_eq!(db.connected(), ["test"]);
|
||||
db.disconnect("test").await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
[package]
|
||||
name = "ide-drag-out"
|
||||
description = "OS file drags out of an app window, so file managers and transfer clients copy the files: GTK on Linux, OLE on Windows, AppKit on macOS"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[dependencies]
|
||||
|
||||
[target.'cfg(target_os = "linux")'.dependencies]
|
||||
gtk = "0.18"
|
||||
|
||||
[target.'cfg(any(windows, target_os = "macos"))'.dependencies]
|
||||
raw-window-handle = "0.6"
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows = { version = "0.62", features = [
|
||||
"Win32_Foundation",
|
||||
"Win32_Graphics_Gdi",
|
||||
"Win32_System_Com",
|
||||
"Win32_System_Com_StructuredStorage",
|
||||
"Win32_System_Memory",
|
||||
"Win32_System_Ole",
|
||||
"Win32_System_SystemServices",
|
||||
"Win32_UI_Shell",
|
||||
"Win32_UI_Shell_Common",
|
||||
] }
|
||||
# `#[implement]` expands to paths into `windows_core`.
|
||||
windows-core = "0.62"
|
||||
|
||||
[target.'cfg(target_os = "macos")'.dependencies]
|
||||
objc2 = { version = "0.6", default-features = false, features = ["std"] }
|
||||
objc2-foundation = { version = "0.3", default-features = false, features = ["std", "NSArray", "NSGeometry", "NSObject", "NSString", "NSURL"] }
|
||||
objc2-app-kit = { version = "0.3", default-features = false, features = [
|
||||
"std",
|
||||
"objc2-core-foundation",
|
||||
"NSApplication",
|
||||
"NSDragging",
|
||||
"NSDraggingItem",
|
||||
"NSDraggingSession",
|
||||
"NSEvent",
|
||||
"NSGraphics",
|
||||
"NSGraphicsContext",
|
||||
"NSImage",
|
||||
"NSPasteboard",
|
||||
"NSPasteboardItem",
|
||||
"NSResponder",
|
||||
"NSView",
|
||||
"NSWindow",
|
||||
"NSWorkspace",
|
||||
] }
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile.workspace = true
|
||||
@@ -0,0 +1,122 @@
|
||||
//! macOS: an AppKit dragging session with one pasteboard item per path, each a file URL.
|
||||
|
||||
use super::Outcome;
|
||||
use objc2::rc::Retained;
|
||||
use objc2::runtime::ProtocolObject;
|
||||
use objc2::{AnyThread, DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send};
|
||||
use objc2_app_kit::{
|
||||
NSApplication, NSDragOperation, NSDraggingContext, NSDraggingItem, NSDraggingSession, NSDraggingSource, NSEvent,
|
||||
NSEventModifierFlags, NSEventType, NSPasteboardItem, NSPasteboardTypeFileURL, NSView, NSWorkspace,
|
||||
};
|
||||
use objc2_foundation::{NSArray, NSObject, NSObjectProtocol, NSPoint, NSRect, NSSize, NSString, NSURL};
|
||||
use raw_window_handle::{HasWindowHandle, RawWindowHandle};
|
||||
use std::cell::Cell;
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// The size of each file's icon under the pointer, in points.
|
||||
const ICON_SIZE: f64 = 32.0;
|
||||
|
||||
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`, each shown with its
|
||||
/// Finder icon; `done` runs on the main thread when the drag ends.
|
||||
pub fn start<W: HasWindowHandle>(
|
||||
window: &W,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
let mtm = MainThreadMarker::new().ok_or_else(|| io::Error::other("a drag starts on the main thread"))?;
|
||||
let RawWindowHandle::AppKit(handle) =
|
||||
window.window_handle().map_err(|error| io::Error::other(error.to_string()))?.as_raw()
|
||||
else {
|
||||
return Err(io::Error::other("not an AppKit window"));
|
||||
};
|
||||
// SAFETY: the handle names this window's view, alive while `window` is borrowed.
|
||||
let view = unsafe { handle.ns_view.cast::<NSView>().as_ref() };
|
||||
let window = view.window().ok_or_else(|| io::Error::other("the view has no window"))?;
|
||||
let content = window.contentView().ok_or_else(|| io::Error::other("the window has no content view"))?;
|
||||
// In window coordinates, which are the content view's.
|
||||
let pointer = window.mouseLocationOutsideOfEventStream();
|
||||
let frame = NSRect::new(
|
||||
NSPoint::new(pointer.x - ICON_SIZE / 2.0, pointer.y - ICON_SIZE / 2.0),
|
||||
NSSize::new(ICON_SIZE, ICON_SIZE),
|
||||
);
|
||||
|
||||
let workspace = NSWorkspace::sharedWorkspace();
|
||||
let mut items = Vec::with_capacity(paths.len());
|
||||
for path in &paths {
|
||||
let path = NSString::from_str(&path.to_string_lossy());
|
||||
let url = NSURL::fileURLWithPath(&path)
|
||||
.absoluteString()
|
||||
.ok_or_else(|| io::Error::other(format!("not a file URL: {path}")))?;
|
||||
let item = NSPasteboardItem::new();
|
||||
if !item.setString_forType(&url, unsafe { NSPasteboardTypeFileURL }) {
|
||||
return Err(io::Error::other(format!("cannot put {path} on the pasteboard")));
|
||||
}
|
||||
let drag_item =
|
||||
NSDraggingItem::initWithPasteboardWriter(NSDraggingItem::alloc(), ProtocolObject::from_ref(&*item));
|
||||
let icon = workspace.iconForFile(&path);
|
||||
unsafe { drag_item.setDraggingFrame_contents(frame, Some(&icon)) };
|
||||
items.push(drag_item);
|
||||
}
|
||||
|
||||
// The session starts from a drag event at the pointer: the web view's own mouse events
|
||||
// went to WebKit, and the current event may be a later one.
|
||||
let timestamp = NSApplication::sharedApplication(mtm).currentEvent().map_or(0.0, |event| event.timestamp());
|
||||
let event = NSEvent::mouseEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_clickCount_pressure(
|
||||
NSEventType::LeftMouseDragged,
|
||||
pointer,
|
||||
NSEventModifierFlags::empty(),
|
||||
timestamp,
|
||||
window.windowNumber(),
|
||||
None,
|
||||
0,
|
||||
1,
|
||||
1.0,
|
||||
)
|
||||
.ok_or_else(|| io::Error::other("cannot make the drag event"))?;
|
||||
let source = DragSource::new(Box::new(done), mtm);
|
||||
content.beginDraggingSessionWithItems_event_source(
|
||||
&NSArray::from_retained_slice(&items),
|
||||
&event,
|
||||
ProtocolObject::from_ref(&*source),
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
type Done = Box<dyn FnOnce(Outcome)>;
|
||||
|
||||
struct Ivars {
|
||||
done: Cell<Option<Done>>,
|
||||
}
|
||||
|
||||
define_class!(
|
||||
#[unsafe(super(NSObject))]
|
||||
#[thread_kind = MainThreadOnly]
|
||||
#[name = "OpenIdeaDragOutSource"]
|
||||
#[ivars = Ivars]
|
||||
struct DragSource;
|
||||
|
||||
unsafe impl NSObjectProtocol for DragSource {}
|
||||
|
||||
unsafe impl NSDraggingSource for DragSource {
|
||||
#[unsafe(method(draggingSession:sourceOperationMaskForDraggingContext:))]
|
||||
fn operation_mask(&self, session: &NSDraggingSession, _context: NSDraggingContext) -> NSDragOperation {
|
||||
session.setAnimatesToStartingPositionsOnCancelOrFail(true);
|
||||
NSDragOperation::Copy
|
||||
}
|
||||
|
||||
#[unsafe(method(draggingSession:endedAtPoint:operation:))]
|
||||
fn ended(&self, _session: &NSDraggingSession, _point: NSPoint, operation: NSDragOperation) {
|
||||
if let Some(done) = self.ivars().done.take() {
|
||||
done(if operation == NSDragOperation::None { Outcome::Cancelled } else { Outcome::Dropped });
|
||||
}
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
impl DragSource {
|
||||
fn new(done: Done, mtm: MainThreadMarker) -> Retained<Self> {
|
||||
let this = Self::alloc(mtm).set_ivars(Ivars { done: Cell::new(Some(done)) });
|
||||
unsafe { msg_send![super(this), init] }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,190 @@
|
||||
//! OS file drags out of an app window: the app the files are dropped on (Explorer,
|
||||
//! Finder, a file manager, an SFTP client such as Xftp) copies them, as when they are
|
||||
//! dragged from IDEA's Project view (#2867).
|
||||
//!
|
||||
//! Linux starts a GTK drag offering `text/uri-list`, Windows an OLE `DoDragDrop` of a
|
||||
//! `CF_HDROP` data object, macOS an AppKit dragging session of file URLs. A drag is
|
||||
//! always a copy, never a move, so no target can take project files away.
|
||||
//!
|
||||
//! [`start`] runs on the UI thread while the primary button is still held. It returns
|
||||
//! once the drag has begun (Linux, macOS) or ended (Windows); `done` gets the outcome
|
||||
//! when it ends, or is dropped without being called when the backend lost track of it.
|
||||
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// How a drag ended.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Outcome {
|
||||
/// A target accepted the drop.
|
||||
Dropped,
|
||||
/// Released where nothing accepted it, or cancelled with Escape.
|
||||
Cancelled,
|
||||
}
|
||||
|
||||
/// The paths a drag may carry: at least one, each an absolute path to a file or folder
|
||||
/// on this machine. A remote project's paths name files on its server and fail here.
|
||||
/// Windows also refuses paths of `MAX_PATH` or more: Explorer can't copy from them.
|
||||
/// Network shares (`\\server\share\…`) are local paths here and drag like any other.
|
||||
pub fn local_paths<S: Into<PathBuf>>(paths: impl IntoIterator<Item = S>) -> io::Result<Vec<PathBuf>> {
|
||||
let paths: Vec<PathBuf> = paths.into_iter().map(Into::into).collect();
|
||||
if paths.is_empty() {
|
||||
return Err(io::Error::new(io::ErrorKind::InvalidInput, "no files to drag"));
|
||||
}
|
||||
for path in &paths {
|
||||
if !path.is_absolute() || std::fs::symlink_metadata(path).is_err() {
|
||||
return Err(io::Error::new(io::ErrorKind::NotFound, format!("not a local file: {}", path.display())));
|
||||
}
|
||||
if cfg!(windows) && !fits_max_path(path) {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
format!("path too long to drag: {}", path.display()),
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(paths)
|
||||
}
|
||||
|
||||
/// Whether `path` is shorter than Windows' `MAX_PATH` (260 UTF-16 units with the NUL).
|
||||
fn fits_max_path(path: &std::path::Path) -> bool {
|
||||
path.as_os_str().to_string_lossy().encode_utf16().count() < 260
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
pub use gtk_impl::start;
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
mod gtk_impl {
|
||||
use super::Outcome;
|
||||
use gtk::glib::{self, SignalHandlerId};
|
||||
use gtk::prelude::*;
|
||||
use gtk::{TargetList, gdk};
|
||||
use std::cell::{Cell, RefCell};
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
use std::rc::Rc;
|
||||
|
||||
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`; `done` runs on
|
||||
/// the UI thread when the drag ends.
|
||||
pub fn start(
|
||||
window: >k::ApplicationWindow,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
// `file://` URIs with every reserved or non-ASCII byte escaped.
|
||||
let uris = paths
|
||||
.iter()
|
||||
.map(|path| glib::filename_to_uri(path, None).map(|uri| uri.to_string()))
|
||||
.collect::<Result<Vec<_>, _>>()
|
||||
.map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error.to_string()))?;
|
||||
let targets = TargetList::new(&[]);
|
||||
targets.add_uri_targets(0);
|
||||
// The button that started the drag (1), not its mask: GTK ends the drag on that
|
||||
// button's release.
|
||||
let context = window
|
||||
.drag_begin_with_coordinates(&targets, gdk::DragAction::COPY, 1, None, -1, -1)
|
||||
.ok_or_else(|| io::Error::other("the window system refused to start a drag"))?;
|
||||
|
||||
let outcome = Rc::new(Cell::new(Outcome::Cancelled));
|
||||
context.connect_drop_performed({
|
||||
let outcome = outcome.clone();
|
||||
move |_, _| outcome.set(Outcome::Dropped)
|
||||
});
|
||||
let handlers: Rc<RefCell<Vec<SignalHandlerId>>> = Rc::default();
|
||||
let data = window.connect_drag_data_get({
|
||||
let context = context.clone();
|
||||
move |_, ctx, selection, _, _| {
|
||||
if *ctx == context {
|
||||
let uris: Vec<&str> = uris.iter().map(String::as_str).collect();
|
||||
selection.set_uris(&uris);
|
||||
}
|
||||
}
|
||||
});
|
||||
// The target asks for the data after the drop (XDND is asynchronous), so the data
|
||||
// handler stays connected until `drag-end`, which GTK emits last.
|
||||
let done = Cell::new(Some(done));
|
||||
let end = window.connect_drag_end({
|
||||
let handlers = handlers.clone();
|
||||
move |window, ctx| {
|
||||
if *ctx != context {
|
||||
return;
|
||||
}
|
||||
for handler in handlers.borrow_mut().drain(..) {
|
||||
window.disconnect(handler);
|
||||
}
|
||||
if let Some(done) = done.take() {
|
||||
done(outcome.get());
|
||||
}
|
||||
}
|
||||
});
|
||||
handlers.borrow_mut().extend([data, end]);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
mod ole;
|
||||
#[cfg(windows)]
|
||||
pub use ole::start;
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
mod appkit;
|
||||
#[cfg(target_os = "macos")]
|
||||
pub use appkit::start;
|
||||
|
||||
/// The `CF_HDROP` file list: each path in UTF-16 with `/` as `\\`, NUL-terminated, and a
|
||||
/// second NUL after the last.
|
||||
#[cfg(any(windows, test))]
|
||||
fn hdrop_file_list<P: IntoIterator<Item = u16>>(paths: impl IntoIterator<Item = P>) -> Vec<u16> {
|
||||
let mut list = Vec::new();
|
||||
for path in paths {
|
||||
list.extend(path.into_iter().map(|unit| if unit == u16::from(b'/') { u16::from(b'\\') } else { unit }));
|
||||
list.push(0);
|
||||
}
|
||||
list.push(0);
|
||||
list
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn accepts_existing_absolute_files_and_folders() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let file = dir.path().join("a b ü.txt");
|
||||
std::fs::write(&file, "x").unwrap();
|
||||
let paths = local_paths([file.clone(), dir.path().to_path_buf()]).unwrap();
|
||||
assert_eq!(paths, vec![file, dir.path().to_path_buf()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn measures_max_path_in_utf16_units() {
|
||||
let path = |len: usize| PathBuf::from(format!("C:/{}", "中".repeat(len - 3)));
|
||||
assert!(fits_max_path(&path(259)));
|
||||
assert!(!fits_max_path(&path(260)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lists_hdrop_files_double_nul_terminated() {
|
||||
let list = hdrop_file_list(["C:/a b/ü.txt", r"\\nas\share\中"].map(str::encode_utf16));
|
||||
let expected: Vec<u16> = "C:\\a b\\ü.txt\0\\\\nas\\share\\中\0\0".encode_utf16().collect();
|
||||
assert_eq!(list, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_an_empty_drag() {
|
||||
assert_eq!(local_paths(Vec::<PathBuf>::new()).unwrap_err().kind(), io::ErrorKind::InvalidInput);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_relative_and_missing_paths() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let file = dir.path().join("a.txt");
|
||||
std::fs::write(&file, "x").unwrap();
|
||||
// One path that is not local fails the whole drag: none of it is half-copied.
|
||||
for bad in [PathBuf::from("a.txt"), dir.path().join("missing.txt")] {
|
||||
assert_eq!(local_paths([file.clone(), bad]).unwrap_err().kind(), io::ErrorKind::NotFound);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,171 @@
|
||||
//! Windows: OLE `DoDragDrop` of a data object that serves the paths as `CF_HDROP`.
|
||||
|
||||
use super::{Outcome, hdrop_file_list};
|
||||
use raw_window_handle::HasWindowHandle;
|
||||
use std::io;
|
||||
use std::os::windows::ffi::OsStrExt;
|
||||
use std::path::PathBuf;
|
||||
use windows::Win32::Foundation::{
|
||||
DRAGDROP_S_CANCEL, DRAGDROP_S_DROP, DRAGDROP_S_USEDEFAULTCURSORS, DV_E_FORMATETC, E_NOTIMPL, GlobalFree, HGLOBAL,
|
||||
OLE_E_ADVISENOTSUPPORTED, S_OK,
|
||||
};
|
||||
use windows::Win32::System::Com::{
|
||||
DATADIR_GET, DVASPECT_CONTENT, FORMATETC, IAdviseSink, IDataObject, IDataObject_Impl, IEnumFORMATETC,
|
||||
IEnumSTATDATA, STGMEDIUM, STGMEDIUM_0, TYMED_HGLOBAL,
|
||||
};
|
||||
use windows::Win32::System::Memory::{GHND, GlobalAlloc, GlobalLock, GlobalUnlock};
|
||||
use windows::Win32::System::Ole::{
|
||||
CF_HDROP, DROPEFFECT, DROPEFFECT_COPY, DROPEFFECT_NONE, DoDragDrop, IDropSource, IDropSource_Impl, OleInitialize,
|
||||
OleUninitialize,
|
||||
};
|
||||
use windows::Win32::System::SystemServices::{MK_LBUTTON, MODIFIERKEYS_FLAGS};
|
||||
use windows::Win32::UI::Shell::{DROPFILES, SHCreateDataObject, SHCreateStdEnumFmtEtc};
|
||||
use windows::core::{BOOL, Error, HRESULT, Ref, Result, implement};
|
||||
|
||||
/// Drags `paths` (see [`super::local_paths`]) until the button is released, then calls
|
||||
/// `done` and returns. `DoDragDrop` runs its own message loop, so the window keeps painting.
|
||||
pub fn start<W: HasWindowHandle>(
|
||||
_window: &W,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
let files = hdrop_file_list(paths.iter().map(|path| path.as_os_str().encode_wide()));
|
||||
// The window's event loop has initialised OLE on this thread already; this takes a
|
||||
// reference that `OleUninitialize` gives back.
|
||||
unsafe { OleInitialize(None) }.map_err(io::Error::other)?;
|
||||
let outcome = drag(files);
|
||||
unsafe { OleUninitialize() };
|
||||
done(outcome.map_err(io::Error::other)?);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn drag(files: Vec<u16>) -> Result<Outcome> {
|
||||
// Formats other than `CF_HDROP` (the drag image, drop descriptions the shell sets on
|
||||
// the source's data object) are kept by a plain shell data object.
|
||||
let inner: IDataObject = unsafe { SHCreateDataObject(None, None, None::<&IDataObject>) }?;
|
||||
let data: IDataObject = DataObject { files, inner }.into();
|
||||
let source: IDropSource = DropSource.into();
|
||||
let mut effect = DROPEFFECT_NONE;
|
||||
match unsafe { DoDragDrop(&data, &source, DROPEFFECT_COPY, &mut effect) } {
|
||||
DRAGDROP_S_DROP if effect != DROPEFFECT_NONE => Ok(Outcome::Dropped),
|
||||
DRAGDROP_S_DROP | DRAGDROP_S_CANCEL => Ok(Outcome::Cancelled),
|
||||
error => Err(Error::from_hresult(error)),
|
||||
}
|
||||
}
|
||||
|
||||
#[implement(IDropSource)]
|
||||
struct DropSource;
|
||||
|
||||
impl IDropSource_Impl for DropSource_Impl {
|
||||
fn QueryContinueDrag(&self, escape_pressed: BOOL, keys: MODIFIERKEYS_FLAGS) -> HRESULT {
|
||||
if escape_pressed.as_bool() {
|
||||
DRAGDROP_S_CANCEL
|
||||
} else if keys & MK_LBUTTON == MODIFIERKEYS_FLAGS(0) {
|
||||
DRAGDROP_S_DROP
|
||||
} else {
|
||||
S_OK
|
||||
}
|
||||
}
|
||||
|
||||
fn GiveFeedback(&self, _effect: DROPEFFECT) -> HRESULT {
|
||||
DRAGDROP_S_USEDEFAULTCURSORS
|
||||
}
|
||||
}
|
||||
|
||||
#[implement(IDataObject)]
|
||||
struct DataObject {
|
||||
/// The `DROPFILES` file list ([`hdrop_file_list`]).
|
||||
files: Vec<u16>,
|
||||
inner: IDataObject,
|
||||
}
|
||||
|
||||
const HDROP: FORMATETC = FORMATETC {
|
||||
cfFormat: CF_HDROP.0,
|
||||
ptd: std::ptr::null_mut(),
|
||||
dwAspect: DVASPECT_CONTENT.0,
|
||||
lindex: -1,
|
||||
tymed: TYMED_HGLOBAL.0 as u32,
|
||||
};
|
||||
|
||||
fn is_hdrop(format: *const FORMATETC) -> bool {
|
||||
unsafe { format.as_ref() }.is_some_and(|format| {
|
||||
format.cfFormat == HDROP.cfFormat && format.dwAspect == HDROP.dwAspect && format.tymed & HDROP.tymed != 0
|
||||
})
|
||||
}
|
||||
|
||||
impl DataObject {
|
||||
/// A new `DROPFILES` block; the receiver frees it.
|
||||
fn hdrop(&self) -> Result<HGLOBAL> {
|
||||
let header = size_of::<DROPFILES>();
|
||||
let size = header + std::mem::size_of_val(self.files.as_slice());
|
||||
unsafe {
|
||||
let handle = GlobalAlloc(GHND, size)?;
|
||||
let block = GlobalLock(handle).cast::<u8>();
|
||||
if block.is_null() {
|
||||
let error = Error::from_thread();
|
||||
let _ = GlobalFree(Some(handle));
|
||||
return Err(error);
|
||||
}
|
||||
block.cast::<DROPFILES>().write_unaligned(DROPFILES {
|
||||
pFiles: header as u32,
|
||||
fWide: true.into(),
|
||||
..Default::default()
|
||||
});
|
||||
std::ptr::copy_nonoverlapping(self.files.as_ptr().cast::<u8>(), block.add(header), size - header);
|
||||
// Fails with no error once the lock count is back to zero, which it is.
|
||||
let _ = GlobalUnlock(handle);
|
||||
Ok(handle)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl IDataObject_Impl for DataObject_Impl {
|
||||
fn GetData(&self, format: *const FORMATETC) -> Result<STGMEDIUM> {
|
||||
if !is_hdrop(format) {
|
||||
return unsafe { self.inner.GetData(format) };
|
||||
}
|
||||
Ok(STGMEDIUM {
|
||||
tymed: TYMED_HGLOBAL.0 as u32,
|
||||
u: STGMEDIUM_0 { hGlobal: self.hdrop()? },
|
||||
pUnkForRelease: std::mem::ManuallyDrop::new(None),
|
||||
})
|
||||
}
|
||||
|
||||
fn GetDataHere(&self, format: *const FORMATETC, medium: *mut STGMEDIUM) -> Result<()> {
|
||||
if is_hdrop(format) {
|
||||
return Err(DV_E_FORMATETC.into());
|
||||
}
|
||||
unsafe { self.inner.GetDataHere(format, medium) }
|
||||
}
|
||||
|
||||
fn QueryGetData(&self, format: *const FORMATETC) -> HRESULT {
|
||||
if is_hdrop(format) { S_OK } else { unsafe { self.inner.QueryGetData(format) } }
|
||||
}
|
||||
|
||||
fn GetCanonicalFormatEtc(&self, format: *const FORMATETC, canonical: *mut FORMATETC) -> HRESULT {
|
||||
unsafe { self.inner.GetCanonicalFormatEtc(format, canonical) }
|
||||
}
|
||||
|
||||
fn SetData(&self, format: *const FORMATETC, medium: *const STGMEDIUM, release: BOOL) -> Result<()> {
|
||||
unsafe { self.inner.SetData(format, medium, release.as_bool()) }
|
||||
}
|
||||
|
||||
fn EnumFormatEtc(&self, direction: u32) -> Result<IEnumFORMATETC> {
|
||||
if direction != DATADIR_GET.0 as u32 {
|
||||
return Err(E_NOTIMPL.into());
|
||||
}
|
||||
unsafe { SHCreateStdEnumFmtEtc(&[HDROP]) }
|
||||
}
|
||||
|
||||
fn DAdvise(&self, _format: *const FORMATETC, _advf: u32, _sink: Ref<IAdviseSink>) -> Result<u32> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
|
||||
fn DUnadvise(&self, _connection: u32) -> Result<()> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
|
||||
fn EnumDAdvise(&self) -> Result<IEnumSTATDATA> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
}
|
||||
@@ -5,10 +5,10 @@ use crate::Host;
|
||||
use crate::agent_secrets::{AgentSecrets, Kept};
|
||||
use ide_agent::registry::{AgentRegistry, RegistryPaths};
|
||||
use ide_agent::{
|
||||
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, AgentContextUsage,
|
||||
AgentEntry, AgentEvent, AgentModelCatalog, AgentProbe, AgentPrompt, AgentProvider, AgentQueued, AgentTask,
|
||||
CustomAgentInput, ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer,
|
||||
McpServerInput, McpTransport, NewAgentTask,
|
||||
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCliOffer,
|
||||
AgentCliUpdateResult, AgentCommand, AgentContextUsage, AgentEntry, AgentEvent, AgentModelCatalog, AgentProbe,
|
||||
AgentPrompt, AgentProvider, AgentQueued, AgentTask, CustomAgentInput, ExternalSession, McpExternalSource,
|
||||
McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput, McpTransport, NewAgentTask,
|
||||
};
|
||||
use ide_command::command;
|
||||
use ide_core::error::ErrorKind;
|
||||
@@ -17,12 +17,28 @@ use ide_tools::InstallEvent;
|
||||
use std::collections::HashSet;
|
||||
use std::sync::{LazyLock, Mutex};
|
||||
|
||||
/// Streams the project's agent events to this window; returns every task.
|
||||
/// Streams the project's agent events to `subscriber`, one of the project's windows (a remote
|
||||
/// host sees them all as one `window`); returns every task.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_subscribe(host: &Host, window: &str, on_event: Channel<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
|
||||
Ok(host.project(window)?.agents.subscribe(std::sync::Arc::new(move |e| {
|
||||
let _ = on_event.send(e);
|
||||
})))
|
||||
pub fn agent_subscribe(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
on_event: Channel<AgentEvent>,
|
||||
subscriber: String,
|
||||
) -> IdeResult<Vec<AgentTask>> {
|
||||
Ok(host.project(window)?.agents.subscribe_as(
|
||||
&subscriber,
|
||||
std::sync::Arc::new(move |e| {
|
||||
let _ = on_event.send(e);
|
||||
}),
|
||||
))
|
||||
}
|
||||
|
||||
/// Stops the events of a window that closed.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_unsubscribe(host: &Host, window: &str, subscriber: String) -> IdeResult<()> {
|
||||
host.project(window)?.agents.unsubscribe(&subscriber);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
@@ -343,6 +359,50 @@ pub async fn agent_rollback(host: &Host, window: &str, task: String, turns: u32)
|
||||
host.project(window)?.agents.rollback(&task, turns).await
|
||||
}
|
||||
|
||||
/// Checks the selected installation without modifying it.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_cli_update_check(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
request: RequestId,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
cli_update(host, window, provider, None, request).await
|
||||
}
|
||||
|
||||
/// Installs the exact version offered if the selected installation still matches.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_cli_update(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
offer: AgentCliOffer,
|
||||
request: RequestId,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
cli_update(host, window, provider, Some(offer), request).await
|
||||
}
|
||||
|
||||
async fn cli_update(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
offer: Option<AgentCliOffer>,
|
||||
request: RequestId,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
let installing = offer.as_ref().map(|_| Installing::begin(&provider)).transpose()?;
|
||||
let cancel = host.begin_project_request(window, request);
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
let _installing = installing;
|
||||
project.agents.cli_update(&provider, offer.as_ref(), &cancel)
|
||||
})
|
||||
.await
|
||||
.map_err(join_err);
|
||||
host.end_request(request);
|
||||
result?
|
||||
}
|
||||
|
||||
/// What the agent reports about itself when it starts (no session: no MCP servers, hooks
|
||||
/// or sign-in run). Remembered until `refresh`.
|
||||
#[command(trust = trusted)]
|
||||
@@ -1086,6 +1146,8 @@ ide_command::domain!(
|
||||
agent_cancel,
|
||||
agent_context_usage,
|
||||
agent_changes,
|
||||
agent_cli_update,
|
||||
agent_cli_update_check,
|
||||
agent_commands,
|
||||
agent_create,
|
||||
agent_delete,
|
||||
@@ -1125,4 +1187,5 @@ ide_command::domain!(
|
||||
agent_subscribe,
|
||||
agent_unarchive,
|
||||
agent_unqueue,
|
||||
agent_unsubscribe,
|
||||
);
|
||||
@@ -1,6 +1,7 @@
|
||||
//! Cucumber sources: the project's `.feature` files and the JavaScript / TypeScript files
|
||||
//! (`@cucumber/cucumber`, `playwright-bdd`) and Java / Kotlin files (cucumber-jvm's
|
||||
//! `@Given("…")` annotations and Java 8 lambdas) that could define steps, with their text. The UI
|
||||
//! `@Given("…")` annotations and Java 8 lambdas) and Python files (behave and pytest-bdd's
|
||||
//! `@given('…')` decorators) that could define steps, with their text. The UI
|
||||
//! owns the Gherkin and step-expression parsing and the index it feeds (as for `routes`),
|
||||
//! so this side stays a cheap scan.
|
||||
|
||||
@@ -21,6 +22,8 @@ const MAX_FILE_BYTES: u64 = 2 << 20;
|
||||
|
||||
/// What a step definition call starts with (`Given('…'`, `defineStep(/…/`).
|
||||
const STEP_CALLS: [&str; 5] = ["Given(", "When(", "Then(", "Step(", "defineStep("];
|
||||
/** What a Python step decorator starts with (behave also takes the capitalized names). */
|
||||
const PYTHON_STEP_CALLS: [&str; 8] = ["@given(", "@when(", "@then(", "@step(", "@Given(", "@When(", "@Then(", "@Step("];
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -38,10 +41,14 @@ fn is_feature(path: &Path) -> bool {
|
||||
fn is_script(path: &Path) -> bool {
|
||||
matches!(
|
||||
path.extension().and_then(|e| e.to_str()),
|
||||
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt")
|
||||
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt" | "py")
|
||||
)
|
||||
}
|
||||
|
||||
fn is_python(path: &Path) -> bool {
|
||||
path.extension().and_then(|e| e.to_str()) == Some("py")
|
||||
}
|
||||
|
||||
/// The feature files and step definition files under `root`.
|
||||
pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
|
||||
let found: Mutex<Vec<StepSource>> = Mutex::new(Vec::new());
|
||||
@@ -55,7 +62,8 @@ pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
|
||||
return;
|
||||
}
|
||||
let Ok(text) = std::fs::read_to_string(path) else { return };
|
||||
if !feature && !STEP_CALLS.iter().any(|call| text.contains(call)) {
|
||||
let calls: &[&str] = if is_python(path) { &PYTHON_STEP_CALLS } else { &STEP_CALLS };
|
||||
if !feature && !calls.iter().any(|call| text.contains(call)) {
|
||||
return;
|
||||
}
|
||||
let Ok(mut found) = found.lock() else { return };
|
||||
@@ -76,6 +84,7 @@ pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult<Vec<StepSource>>
|
||||
let mut excludes = project.search_excludes();
|
||||
// Cucumber's own sources (and every other package's) are not the project's steps.
|
||||
excludes.push("node_modules".to_owned());
|
||||
excludes.push("site-packages".to_owned());
|
||||
let mut out = Vec::new();
|
||||
for root in std::iter::once(project.root.clone()).chain(project.content_roots()) {
|
||||
out.extend(sources_in(&root, &excludes));
|
||||
@@ -104,11 +113,23 @@ mod tests {
|
||||
std::fs::write(root.join("src/CartSteps.java"), "@Given(\"an empty cart\")\npublic void empty() {}").unwrap();
|
||||
std::fs::write(root.join("src/App.java"), "class App {}").unwrap();
|
||||
std::fs::write(root.join("src/notes.md"), "Given('x')").unwrap();
|
||||
std::fs::write(root.join("steps/cart_steps.py"), "@given('an empty cart')\ndef step_impl(context): pass")
|
||||
.unwrap();
|
||||
std::fs::write(root.join("src/util.py"), "def given(x): return x\nWhen = given('x')").unwrap();
|
||||
std::fs::write(root.join("node_modules/@cucumber/cucumber/lib/index.js"), "Given('x')").unwrap();
|
||||
let files = sources_in(root, &["node_modules".to_owned()]);
|
||||
let names: Vec<String> =
|
||||
files.iter().map(|f| f.path.0.strip_prefix(root).unwrap().to_string_lossy().replace('\\', "/")).collect();
|
||||
assert_eq!(names, ["features/cart.feature", "src/CartSteps.java", "steps/bdd.mjs", "steps/cart.steps.ts"]);
|
||||
assert_eq!(
|
||||
names,
|
||||
[
|
||||
"features/cart.feature",
|
||||
"src/CartSteps.java",
|
||||
"steps/bdd.mjs",
|
||||
"steps/cart.steps.ts",
|
||||
"steps/cart_steps.py"
|
||||
]
|
||||
);
|
||||
assert!(files[0].feature && !files[1].feature);
|
||||
assert!(files[3].text.contains("an empty cart"));
|
||||
}
|
||||
|
||||
@@ -633,8 +633,14 @@ pub async fn vcs_add_to_ignore(
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
blocking(move || {
|
||||
// The Changes view lists every repository of the window (the project's and the
|
||||
// attached ones'): a path inside the project folder, or in any of those repositories.
|
||||
// The folder check stays so a request right after opening, before the repositories
|
||||
// are discovered, still works.
|
||||
let repos = project.repos();
|
||||
for path in &paths {
|
||||
if path == &project.root || !path.starts_with(&project.root) {
|
||||
let in_project = path != &project.root && path.starts_with(&project.root);
|
||||
if !in_project && repos.for_path(path).is_none() {
|
||||
return Err(ide_core::IdeError::invalid("Ignore selection is outside the project"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -21,6 +21,7 @@ async fn patches_read_and_write_the_requested_repository() {
|
||||
git(root, &["init", "-b", "main"]);
|
||||
git(root, &["config", "user.name", "Test"]);
|
||||
git(root, &["config", "user.email", "[email protected]"]);
|
||||
git(root, &["config", "core.autocrlf", "false"]);
|
||||
std::fs::write(root.join("same.txt"), format!("root {i}\n")).unwrap();
|
||||
git(root, &["add", "."]);
|
||||
git(root, &["commit", "-m", "initial"]);
|
||||
@@ -65,3 +66,75 @@ async fn patches_read_and_write_the_requested_repository() {
|
||||
assert!(vcs::vcs_apply_patch(&host, "main", Some(base.join("outside")), String::new()).await.is_err());
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
/// The Changes view also lists attached projects' repositories, and their untracked files
|
||||
/// offer Add to .gitignore / .git/info/exclude: the guard must follow the window's
|
||||
/// repository set, not the project folder alone.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn add_to_ignore_accepts_the_repositories_of_attached_projects() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let project_root = base.join("project");
|
||||
let attached_root = base.join("attached");
|
||||
for root in [&project_root, &attached_root] {
|
||||
std::fs::create_dir_all(root).unwrap();
|
||||
git(root, &["init", "-b", "main"]);
|
||||
git(root, &["config", "user.name", "Test"]);
|
||||
git(root, &["config", "user.email", "[email protected]"]);
|
||||
git(root, &["config", "core.autocrlf", "false"]);
|
||||
std::fs::write(root.join("tracked.txt"), "x\n").unwrap();
|
||||
git(root, &["add", "."]);
|
||||
git(root, &["commit", "-m", "initial"]);
|
||||
}
|
||||
// Untracked files, one per repository; the attached one is what failed.
|
||||
let own = project_root.join("own.ignore-me");
|
||||
let attached = attached_root.join("attached.ignore-me");
|
||||
std::fs::write(&own, "x").unwrap();
|
||||
std::fs::write(&attached, "x").unwrap();
|
||||
|
||||
let host = Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("data"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(|_| Arc::new(NullSink)),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
});
|
||||
host.trust.decide(&project_root, true, false).unwrap();
|
||||
host.trust.decide(&attached_root, true, false).unwrap();
|
||||
let project = host.open_project("main", &project_root).unwrap();
|
||||
ide_host::ops::project::attach_workspace(&host, "main", &attached_root).unwrap();
|
||||
for _ in 0..500 {
|
||||
if project.repos().all().len() == 2 {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
assert_eq!(project.repos().all().len(), 2);
|
||||
|
||||
vcs::vcs_add_to_ignore(&host, "main", vec![attached.clone()], ide_vcs::IgnoreDestination::Gitignore).await.unwrap();
|
||||
assert!(
|
||||
std::fs::read_to_string(attached_root.join(".gitignore")).unwrap().contains("/attached.ignore-me"),
|
||||
"the attached repository's .gitignore did not receive the rule"
|
||||
);
|
||||
vcs::vcs_add_to_ignore(&host, "main", vec![own.clone()], ide_vcs::IgnoreDestination::LocalExclude).await.unwrap();
|
||||
assert!(
|
||||
std::fs::read_to_string(project_root.join(".git/info/exclude")).unwrap().contains("/own.ignore-me"),
|
||||
"the project repository's exclude did not receive the rule"
|
||||
);
|
||||
|
||||
// A repository of an unattached sibling folder stays outside.
|
||||
let sibling_root = base.join("sibling");
|
||||
std::fs::create_dir_all(&sibling_root).unwrap();
|
||||
git(&sibling_root, &["init", "-b", "main"]);
|
||||
let sibling = sibling_root.join("sibling.ignore-me");
|
||||
std::fs::write(&sibling, "x").unwrap();
|
||||
let error =
|
||||
vcs::vcs_add_to_ignore(&host, "main", vec![sibling], ide_vcs::IgnoreDestination::Gitignore).await.unwrap_err();
|
||||
assert!(error.message.contains("outside the project"), "{error:?}");
|
||||
assert!(!sibling_root.join(".gitignore").exists());
|
||||
host.close_project("main");
|
||||
}
|
||||
@@ -15,6 +15,8 @@ tokio.workspace = true
|
||||
tracing.workspace = true
|
||||
parking_lot.workspace = true
|
||||
reqwest.workspace = true
|
||||
# The system proxy reqwest reads, to notice when it changes (see `client::shared`).
|
||||
hyper-util = { version = "0.1", default-features = false, features = ["client-proxy", "client-proxy-system"] }
|
||||
rustls.workspace = true
|
||||
rustls-platform-verifier.workspace = true
|
||||
uuid.workspace = true
|
||||
|
||||
@@ -5,7 +5,7 @@ use ide_core::proxy_settings::{ProxyMode, ProxyRoute, ProxySettings};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use parking_lot::Mutex;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
/// `builder` routed as `proxy` says: direct, the environment's proxy (reqwest's
|
||||
/// default), or the manual proxy except for the "No proxy for" hosts.
|
||||
@@ -62,33 +62,61 @@ pub fn build_with_redirect(proxy: &ProxySettings, redirect: reqwest::redirect::P
|
||||
with_proxy(builder, proxy).build().map_err(|e| fail(e.to_string()))
|
||||
}
|
||||
|
||||
/// A client built for these proxy settings and, in Auto mode, this system proxy.
|
||||
struct Cached {
|
||||
settings: Arc<ProxySettings>,
|
||||
system: Option<String>,
|
||||
client: reqwest::Client,
|
||||
}
|
||||
|
||||
/// The client for the current proxy settings, rebuilt when they change.
|
||||
pub fn shared() -> IdeResult<reqwest::Client> {
|
||||
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, build)
|
||||
static CLIENT: Mutex<Option<Cached>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, build, system_proxy)
|
||||
}
|
||||
|
||||
/// The client the HTTP Client executes requests with: redirects off, `exec`
|
||||
/// follows them by hand — that is what lets a `POST` stay a `POST` on a
|
||||
/// 301/302 and puts the redirect chain into the response.
|
||||
pub fn shared_without_redirects() -> IdeResult<reqwest::Client> {
|
||||
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, |proxy| build_with_redirect(proxy, reqwest::redirect::Policy::none()))
|
||||
static CLIENT: Mutex<Option<Cached>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, |proxy| build_with_redirect(proxy, reqwest::redirect::Policy::none()), system_proxy)
|
||||
}
|
||||
|
||||
/// The system proxy (the environment's, then macOS / Windows settings) as reqwest reads
|
||||
/// it when a client is built, re-read at most every few seconds. A client in Auto mode
|
||||
/// keeps the proxy it was built with, so a proxy app that switches the system proxy on
|
||||
/// after launch would otherwise leave downloads going direct until a restart.
|
||||
fn system_proxy() -> String {
|
||||
static LAST: Mutex<Option<(Instant, String)>> = Mutex::new(None);
|
||||
let mut last = LAST.lock();
|
||||
if let Some((at, seen)) = last.as_ref()
|
||||
&& at.elapsed() < Duration::from_secs(3)
|
||||
{
|
||||
return seen.clone();
|
||||
}
|
||||
// Credentials are left out of the matcher's `Debug`.
|
||||
let seen = format!("{:?}", hyper_util::client::proxy::matcher::Matcher::from_system());
|
||||
*last = Some((Instant::now(), seen.clone()));
|
||||
seen
|
||||
}
|
||||
|
||||
fn cached_client(
|
||||
slot: &Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>>,
|
||||
build: fn(&ProxySettings) -> IdeResult<reqwest::Client>,
|
||||
slot: &Mutex<Option<Cached>>,
|
||||
build: impl Fn(&ProxySettings) -> IdeResult<reqwest::Client>,
|
||||
system: fn() -> String,
|
||||
) -> IdeResult<reqwest::Client> {
|
||||
let proxy = ide_core::proxy_settings::proxy();
|
||||
let system = (proxy.mode == ProxyMode::Auto).then(system);
|
||||
let mut cached = slot.lock();
|
||||
if let Some((settings, client)) = cached.as_ref()
|
||||
&& **settings == *proxy
|
||||
if let Some(c) = cached.as_ref()
|
||||
&& *c.settings == *proxy
|
||||
&& c.system == system
|
||||
{
|
||||
return Ok(client.clone());
|
||||
return Ok(c.client.clone());
|
||||
}
|
||||
let client = build(&proxy)?;
|
||||
*cached = Some((proxy, client.clone()));
|
||||
*cached = Some(Cached { settings: proxy, system, client: client.clone() });
|
||||
Ok(client)
|
||||
}
|
||||
|
||||
@@ -142,6 +170,36 @@ pub fn describe(e: &reqwest::Error) -> String {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn auto_mode_rebuilds_the_shared_client_when_the_system_proxy_changes() {
|
||||
static SYSTEM: Mutex<String> = Mutex::new(String::new());
|
||||
static BUILDS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||||
fn system() -> String {
|
||||
SYSTEM.lock().clone()
|
||||
}
|
||||
let slot = Mutex::new(None);
|
||||
let get = || {
|
||||
cached_client(
|
||||
&slot,
|
||||
|proxy| {
|
||||
BUILDS.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
||||
build(proxy)
|
||||
},
|
||||
system,
|
||||
)
|
||||
.unwrap()
|
||||
};
|
||||
assert_eq!(ide_core::proxy_settings::proxy().mode, ProxyMode::Auto);
|
||||
get();
|
||||
get();
|
||||
assert_eq!(BUILDS.load(std::sync::atomic::Ordering::SeqCst), 1);
|
||||
// A proxy app switches the system proxy on after launch.
|
||||
*SYSTEM.lock() = "Matcher { https: 127.0.0.1:7890 }".into();
|
||||
get();
|
||||
get();
|
||||
assert_eq!(BUILDS.load(std::sync::atomic::Ordering::SeqCst), 2);
|
||||
}
|
||||
use ide_core::proxy_settings::ProxyKind;
|
||||
use std::io::{BufRead, BufReader, Write};
|
||||
use std::net::TcpListener;
|
||||
|
||||
@@ -13,6 +13,9 @@ const FILES: TableDefinition<&str, &[u8]> = TableDefinition::new("files");
|
||||
const META: TableDefinition<&str, &[u8]> = TableDefinition::new("meta");
|
||||
/// Bump when [`FileRecord`] or its encoding changes. 4: a symbol's base names.
|
||||
const SCHEMA: &str = "openidea-index-4";
|
||||
/// redb's page cache, which otherwise grows to 1 GiB. Queries run on the in-memory snapshot;
|
||||
/// the database is read once at startup and written incrementally.
|
||||
const DB_CACHE_BYTES: usize = 64 * 1024 * 1024;
|
||||
|
||||
/// The real Git directory for a checkout/worktree (`root/.git` may be a file
|
||||
/// containing `gitdir: ...`).
|
||||
@@ -389,7 +392,7 @@ impl Store {
|
||||
|
||||
fn open_db(&self) -> Result<Database> {
|
||||
let file = self.snapshot.with_file_name("index.redb");
|
||||
let db = match Database::create(&file) {
|
||||
let db = match Database::builder().set_cache_size(DB_CACHE_BYTES).create(&file) {
|
||||
Ok(db) => db,
|
||||
Err(redb::DatabaseError::DatabaseAlreadyOpen) => {
|
||||
return Err(format!("{} is in use", file.display()));
|
||||
@@ -398,7 +401,7 @@ impl Store {
|
||||
tracing::warn!("index cache {} unreadable ({e}); rebuilding", file.display());
|
||||
let _ = std::fs::remove_file(&file);
|
||||
let _ = std::fs::remove_file(&self.snapshot);
|
||||
Database::create(&file).map_err(err)?
|
||||
Database::builder().set_cache_size(DB_CACHE_BYTES).create(&file).map_err(err)?
|
||||
}
|
||||
};
|
||||
let valid = {
|
||||
|
||||
@@ -472,6 +472,8 @@ impl Shared {
|
||||
|
||||
fn full_scan(&self, found: Option<Vec<Found>>, guard: SystemTime) {
|
||||
self.scan(None, found, guard);
|
||||
// Parsing every file churns through far more memory than the index keeps.
|
||||
ide_core::memory::release_free_pages();
|
||||
}
|
||||
|
||||
fn scan(&self, dirs: Option<&[PathBuf]>, prewalked: Option<Vec<Found>>, guard: SystemTime) -> Option<ScanCounts> {
|
||||
|
||||
@@ -1049,12 +1049,14 @@ impl LspManager {
|
||||
if let Err(e) = peer.notify("initialized", json!({})) {
|
||||
tracing::warn!("{}: {e}", server.name);
|
||||
}
|
||||
// Servers that don't ask with `workspace/configuration` only learn settings this way.
|
||||
let cfg = server.effective_config();
|
||||
if cfg.settings.is_some()
|
||||
&& let Err(e) =
|
||||
peer.notify("workspace/didChangeConfiguration", json!({ "settings": handler::all_settings(&cfg) }))
|
||||
{
|
||||
// Sent even without settings: servers that don't ask with `workspace/configuration`
|
||||
// only learn settings this way, and Pyright, given workspace folders, waits for it
|
||||
// before asking and loading the workspace.
|
||||
let mut settings = handler::all_settings(&server.effective_config());
|
||||
if settings.is_null() {
|
||||
settings = json!({});
|
||||
}
|
||||
if let Err(e) = peer.notify("workspace/didChangeConfiguration", json!({ "settings": settings })) {
|
||||
tracing::debug!("{}: didChangeConfiguration: {e}", server.name);
|
||||
}
|
||||
|
||||
|
||||
@@ -1324,6 +1324,36 @@ async fn initialize_and_incremental_sync() {
|
||||
assert_eq!(infos[0].status, ServerStatus::Ready);
|
||||
}
|
||||
|
||||
/// Pyright, told the client has workspace folders, asks for its configuration and loads the
|
||||
/// workspace only after a `workspace/didChangeConfiguration`: every server gets one at startup.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn every_server_hears_its_configuration_once_initialized() {
|
||||
let cases = [
|
||||
(None, None, json!({})),
|
||||
(Some(json!({ "flag": true })), None, json!({ "flag": true })),
|
||||
(
|
||||
None,
|
||||
Some(json!({ "python": { "pythonPath": "/venv/bin/python" } })),
|
||||
json!({ "python": { "pythonPath": "/venv/bin/python" } }),
|
||||
),
|
||||
(Some(json!({ "flag": true })), Some(json!({ "other": 2 })), json!({ "flag": true, "other": 2 })),
|
||||
];
|
||||
for (init, settings, expected) in cases {
|
||||
let h = harness_configured("mock", "mk", &[("pyright", incremental_caps())], |cfg| {
|
||||
cfg.initialization_options = init.clone().map(|v| toml::Value::try_from(v).unwrap());
|
||||
cfg.settings = settings.clone();
|
||||
});
|
||||
h.open("a.mk", "x");
|
||||
h.wait_status("pyright", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("pyright");
|
||||
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
|
||||
assert_eq!(s.notified("workspace/didChangeConfiguration"), vec![json!({ "settings": expected })]);
|
||||
let order: Vec<String> = s.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
|
||||
let at = |m: &str| order.iter().position(|n| n == m).unwrap();
|
||||
assert!(at("initialized") < at("workspace/didChangeConfiguration"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn full_sync_and_desync_recovery() {
|
||||
let h = harness(&[("full", json!({ "textDocumentSync": 1 })), ("inc", json!({ "textDocumentSync": 2 }))]);
|
||||
@@ -2650,7 +2680,16 @@ async fn configuration_answer_resyncs_open_documents_of_opted_in_servers() {
|
||||
.await;
|
||||
assert_eq!(s.notified("textDocument/didChange").len(), 2, "one re-sync per answer");
|
||||
let methods: Vec<String> = extra.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
|
||||
assert_eq!(methods, ["initialized", "textDocument/didOpen", "textDocument/didChange", "textDocument/didSave"]);
|
||||
assert_eq!(
|
||||
methods,
|
||||
[
|
||||
"initialized",
|
||||
"workspace/didChangeConfiguration",
|
||||
"textDocument/didOpen",
|
||||
"textDocument/didChange",
|
||||
"textDocument/didSave"
|
||||
]
|
||||
);
|
||||
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
@@ -2706,9 +2745,9 @@ async fn settings_changes_reach_servers_without_restarts() {
|
||||
let s = h.launcher.state("mock");
|
||||
*settings.lock() = Some(json!({ "nested": { "other": 2 } }));
|
||||
h.mgr.reconfigure().await;
|
||||
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
|
||||
eventually(|| s.notified("workspace/didChangeConfiguration").len() == 2).await;
|
||||
assert_eq!(
|
||||
s.notified("workspace/didChangeConfiguration")[0],
|
||||
s.notified("workspace/didChangeConfiguration")[1],
|
||||
json!({ "settings": { "flag": true, "nested": { "deep": 1, "other": 2 } } })
|
||||
);
|
||||
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
|
||||
|
||||
@@ -462,35 +462,54 @@ fn main() {
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires ty on PATH"]
|
||||
async fn ty_python_end_to_end() {
|
||||
python_server_end_to_end("ty").await;
|
||||
}
|
||||
|
||||
/// Pyright loads the workspace only after `workspace/didChangeConfiguration`.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires pyright-langserver on PATH"]
|
||||
async fn pyright_python_end_to_end() {
|
||||
python_server_end_to_end("pyright").await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires basedpyright on PATH"]
|
||||
async fn basedpyright_python_end_to_end() {
|
||||
python_server_end_to_end("basedpyright").await;
|
||||
}
|
||||
|
||||
/// Definition and diagnostics from `name` alone, in a project without configuration.
|
||||
async fn python_server_end_to_end(name: &str) {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path().canonicalize().unwrap();
|
||||
let path = root.join("example.py");
|
||||
let source = "def greet(name: str) -> str:\n return name\n\nresult = greet('Ada')\nbad: int = 'wrong'\n";
|
||||
std::fs::write(&path, source).unwrap();
|
||||
let mut python = LanguageRegistry::load(None).unwrap().get(&LanguageId::new("python")).unwrap();
|
||||
python.language_servers.retain(|server| server.name == "ty");
|
||||
python.language_servers.retain(|server| server.name == name);
|
||||
assert_eq!(python.language_servers.len(), 1);
|
||||
python.language_servers[0].fallback = false;
|
||||
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![python]));
|
||||
let doc = DocId::next();
|
||||
mgr.did_open(doc, &path, &LanguageId::new("python"), 1, source);
|
||||
retry("ty ready", Duration::from_secs(30), || {
|
||||
let status = last_status(&events, "ty");
|
||||
retry(&format!("{name} ready"), Duration::from_secs(30), || {
|
||||
let status = last_status(&events, name);
|
||||
if let Some((ServerStatus::Crashed | ServerStatus::Missing | ServerStatus::Misconfigured, msg)) = &status {
|
||||
panic!("ty failed: {msg:?}");
|
||||
panic!("{name} failed: {msg:?}");
|
||||
}
|
||||
async move { matches!(status, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }
|
||||
})
|
||||
.await;
|
||||
let defs = retry("ty definition", Duration::from_secs(30), || {
|
||||
let defs = retry(&format!("{name} definition"), Duration::from_secs(30), || {
|
||||
let mgr = mgr.clone();
|
||||
async move { mgr.goto(doc, Pos::new(3, 10), GotoKind::Definition).await.ok().filter(|d| !d.is_empty()) }
|
||||
})
|
||||
.await;
|
||||
assert_eq!(defs[0].path, path);
|
||||
assert_eq!(defs[0].range.start.line, 0);
|
||||
retry("ty diagnostics", Duration::from_secs(30), || {
|
||||
retry(&format!("{name} diagnostics"), Duration::from_secs(30), || {
|
||||
let found = events.lock().iter().any(
|
||||
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == "ty" && !items.is_empty()),
|
||||
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == name && !items.is_empty()),
|
||||
);
|
||||
async move { found.then_some(()) }
|
||||
})
|
||||
|
||||
@@ -197,28 +197,62 @@ fn software_term(lower: &str) -> bool {
|
||||
.is_some_and(|w| ["s", "x", "z", "ch", "sh"].iter().any(|e| w.ends_with(e)) && plural_of(w))
|
||||
}
|
||||
|
||||
/// Words of a custom dictionary file: a plain word list or a Hunspell `.dic`
|
||||
/// (leading count line and `/FLAGS` ignored). Cached by modification time.
|
||||
fn dictionary_file(path: &Path) -> Arc<HashSet<String>> {
|
||||
type Cache = HashMap<PathBuf, (Option<SystemTime>, Arc<HashSet<String>>)>;
|
||||
static CACHE: OnceLock<Mutex<Cache>> = OnceLock::new();
|
||||
let modified = std::fs::metadata(path).and_then(|m| m.modified()).ok();
|
||||
let mut cache = CACHE.get_or_init(Default::default).lock();
|
||||
if let Some((at, words)) = cache.get(path)
|
||||
&& *at == modified
|
||||
{
|
||||
return words.clone();
|
||||
}
|
||||
let words: HashSet<String> = match std::fs::read_to_string(path) {
|
||||
Ok(text) => parse_word_list(&text),
|
||||
Err(e) => {
|
||||
tracing::debug!("custom dictionary {}: {e}", path.display());
|
||||
HashSet::new()
|
||||
/// A custom dictionary: a word list, or a Hunspell dictionary with its affix rules.
|
||||
enum CustomDictionary {
|
||||
Words(HashSet<String>),
|
||||
Hunspell(Box<spellbook::Dictionary>),
|
||||
}
|
||||
|
||||
impl CustomDictionary {
|
||||
/// Whether the lowercased `lower` is a word of it, in any case style.
|
||||
fn contains(&self, lower: &str) -> bool {
|
||||
match self {
|
||||
Self::Words(words) => words.contains(lower),
|
||||
Self::Hunspell(dict) => {
|
||||
dict.check(lower) || dict.check(&capitalize(lower)) || dict.check(&lower.to_uppercase())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The `.aff` next to a Hunspell `.dic` (`de_DE.dic` → `de_DE.aff`), if there is one.
|
||||
fn affix_file(path: &Path) -> Option<PathBuf> {
|
||||
if !path.extension().is_some_and(|e| e.eq_ignore_ascii_case("dic")) {
|
||||
return None;
|
||||
}
|
||||
["aff", "AFF"].into_iter().map(|ext| path.with_extension(ext)).find(|aff| aff.is_file())
|
||||
}
|
||||
|
||||
/// A custom dictionary file: a Hunspell `.dic` with the `.aff` beside it, with
|
||||
/// its affix, compounding and case rules; otherwise a plain word list (a `.dic`
|
||||
/// alone: leading count line and `/FLAGS` ignored). Cached by modification time.
|
||||
fn dictionary_file(path: &Path) -> Arc<CustomDictionary> {
|
||||
type Stamp = (Option<SystemTime>, Option<SystemTime>);
|
||||
type Cache = HashMap<PathBuf, (Stamp, Arc<CustomDictionary>)>;
|
||||
static CACHE: OnceLock<Mutex<Cache>> = OnceLock::new();
|
||||
let modified = |p: &Path| std::fs::metadata(p).and_then(|m| m.modified()).ok();
|
||||
let aff = affix_file(path);
|
||||
let stamp = (modified(path), aff.as_deref().and_then(modified));
|
||||
if let Some((at, dict)) = CACHE.get_or_init(Default::default).lock().get(path)
|
||||
&& *at == stamp
|
||||
{
|
||||
return dict.clone();
|
||||
}
|
||||
let read = |p: &Path| {
|
||||
std::fs::read_to_string(p).map_err(|e| tracing::debug!("custom dictionary {}: {e}", p.display())).ok()
|
||||
};
|
||||
let words = Arc::new(words);
|
||||
cache.insert(path.to_path_buf(), (modified, words.clone()));
|
||||
words
|
||||
let text = read(path).unwrap_or_default();
|
||||
let hunspell = aff.as_deref().and_then(read).and_then(|aff| {
|
||||
spellbook::Dictionary::new(&aff, &text)
|
||||
.map_err(|e| tracing::warn!("Hunspell dictionary {}: {e}", path.display()))
|
||||
.ok()
|
||||
});
|
||||
let dict = Arc::new(match hunspell {
|
||||
Some(dict) => CustomDictionary::Hunspell(Box::new(dict)),
|
||||
None => CustomDictionary::Words(parse_word_list(&text)),
|
||||
});
|
||||
CACHE.get_or_init(Default::default).lock().insert(path.to_path_buf(), (stamp, dict.clone()));
|
||||
dict
|
||||
}
|
||||
|
||||
/// Lowercased words of a word list / Hunspell `.dic` text.
|
||||
@@ -238,7 +272,7 @@ pub fn parse_word_list(text: &str) -> HashSet<String> {
|
||||
#[derive(Default)]
|
||||
pub struct Speller {
|
||||
accepted: HashSet<String>,
|
||||
custom: Vec<Arc<HashSet<String>>>,
|
||||
custom: Vec<Arc<CustomDictionary>>,
|
||||
}
|
||||
|
||||
impl Speller {
|
||||
@@ -351,16 +385,31 @@ impl Speller {
|
||||
&& !near_word(lower, |w| english().check(w))
|
||||
}
|
||||
|
||||
/// Replacements for `word`, best first, in the word's case style.
|
||||
/// Replacements for `word`, best first, in the word's case style: from the
|
||||
/// English dictionary and the custom Hunspell dictionaries, the closest first.
|
||||
pub fn suggest(&self, word: &str, limit: usize) -> Vec<String> {
|
||||
let hunspell = self.custom.iter().filter_map(|d| match d.as_ref() {
|
||||
CustomDictionary::Hunspell(dict) => Some(dict.as_ref()),
|
||||
CustomDictionary::Words(_) => None,
|
||||
});
|
||||
let dicts: Vec<&spellbook::Dictionary> = std::iter::once(english()).chain(hunspell).collect();
|
||||
let mut out = Vec::new();
|
||||
english().suggest(word, &mut out);
|
||||
if out.is_empty() && word.chars().next().is_some_and(char::is_uppercase) {
|
||||
english().suggest(&word.to_lowercase(), &mut out);
|
||||
out = out.into_iter().map(|s| capitalize(&s)).collect();
|
||||
for dict in &dicts {
|
||||
let mut found = Vec::new();
|
||||
dict.suggest(word, &mut found);
|
||||
if found.is_empty() && word.chars().next().is_some_and(char::is_uppercase) {
|
||||
dict.suggest(&word.to_lowercase(), &mut found);
|
||||
found = found.into_iter().map(|s| capitalize(&s)).collect();
|
||||
}
|
||||
out.extend(found);
|
||||
}
|
||||
let mut seen = HashSet::new();
|
||||
out.retain(|s| s != word && seen.insert(s.clone()));
|
||||
if dicts.len() > 1 {
|
||||
// Stable: within a distance each dictionary keeps its own order, English first.
|
||||
let lower = word.to_lowercase();
|
||||
out.sort_by_key(|s| edit_distance(&lower, &s.to_lowercase()));
|
||||
}
|
||||
out.truncate(limit);
|
||||
out
|
||||
}
|
||||
@@ -416,6 +465,22 @@ impl Speller {
|
||||
}
|
||||
}
|
||||
|
||||
/// Levenshtein distance in characters.
|
||||
fn edit_distance(a: &str, b: &str) -> usize {
|
||||
let b: Vec<char> = b.chars().collect();
|
||||
let mut row: Vec<usize> = (0..=b.len()).collect();
|
||||
for (i, ca) in a.chars().enumerate() {
|
||||
let mut diagonal = row[0];
|
||||
row[0] = i + 1;
|
||||
for (j, cb) in b.iter().enumerate() {
|
||||
let next = (row[j + 1] + 1).min(row[j] + 1).min(diagonal + usize::from(ca != *cb));
|
||||
diagonal = row[j + 1];
|
||||
row[j + 1] = next;
|
||||
}
|
||||
}
|
||||
row[b.len()]
|
||||
}
|
||||
|
||||
fn capitalize(s: &str) -> String {
|
||||
let mut chars = s.chars();
|
||||
chars.next().into_iter().flat_map(char::to_uppercase).chain(chars).collect()
|
||||
@@ -736,6 +801,36 @@ mod tests {
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hunspell_custom_dictionaries_use_their_affix_rules() {
|
||||
let dir = std::env::temp_dir().join(format!("ide-spell-hunspell-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let dic = dir.join("de_TEST.dic");
|
||||
std::fs::write(&dic, "3\nhaus/NZ\ntür/NZ\nschlüssel/Z\n").unwrap();
|
||||
std::fs::write(
|
||||
dir.join("de_TEST.aff"),
|
||||
"SET UTF-8\nTRY esianrtolcdugmphbyfvkwzäöüß\nCOMPOUNDFLAG Z\nSFX N Y 1\nSFX N 0 en .\n",
|
||||
)
|
||||
.unwrap();
|
||||
let s = Speller::new::<&str>([], std::slice::from_ref(&dic));
|
||||
// Affix rules, compounds and case styles of the .aff, not just the listed stems.
|
||||
for word in ["haus", "Haus", "hausen", "türen", "Haustür", "schlüsselhaus"] {
|
||||
assert!(s.is_correct(word), "{word}");
|
||||
}
|
||||
assert!(!s.is_correct("hauz"));
|
||||
assert!(!s.is_correct("schlüsselen"));
|
||||
assert!(s.suggest("Hauss", 5).iter().any(|w| w == "Haus"), "{:?}", s.suggest("Hauss", 5));
|
||||
// English still checks and suggests.
|
||||
assert!(s.is_correct("message"));
|
||||
assert!(s.suggest("mesage", 5).iter().any(|w| w == "message"));
|
||||
// Without its .aff, a .dic is a word list.
|
||||
std::fs::remove_file(dir.join("de_TEST.aff")).unwrap();
|
||||
let words = Speller::new::<&str>([], std::slice::from_ref(&dic));
|
||||
assert!(words.is_correct("haus"));
|
||||
assert!(!words.is_correct("hausen"));
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn utf16_ranges() {
|
||||
let s = Speller::default();
|
||||
|
||||
@@ -372,6 +372,8 @@ fn materialize_row(
|
||||
if let Some((pos, total)) = position {
|
||||
commit.log_position = Some(pos);
|
||||
commit.log_total = Some(total);
|
||||
let merge_time_ms = row.merge_time_secs as f64 * 1000.0;
|
||||
commit.log_merge_time_ms = (merge_time_ms > commit.commit_time_ms).then_some(merge_time_ms);
|
||||
}
|
||||
if !summary_only {
|
||||
commit.message = index.message(repo, row.id)?;
|
||||
@@ -714,17 +716,16 @@ fn log_indexed_rows(
|
||||
skip -= 1;
|
||||
continue;
|
||||
}
|
||||
let parents: Vec<ObjectId> = if shallow.contains(&id) {
|
||||
Vec::new()
|
||||
} else if let Some((ps, _)) = visibility.index.nodes.get(&id) {
|
||||
ps.clone()
|
||||
let (parents, commit_time_secs) = if let Some((parents, time)) = visibility.index.nodes.get(&id) {
|
||||
(parents.clone(), *time)
|
||||
} else {
|
||||
let record = visibility.index.get_with_table(&repo, id, visibility.table)?;
|
||||
record
|
||||
let parents = record
|
||||
.parents
|
||||
.iter()
|
||||
.map(|p| ObjectId::from_hex(p.as_bytes()).map_err(gx))
|
||||
.collect::<IdeResult<Vec<_>>>()?
|
||||
.collect::<IdeResult<Vec<_>>>()?;
|
||||
(parents, (record.commit_time_ms / 1000.0) as i64)
|
||||
};
|
||||
let shown_parents = if shallow.contains(&id) {
|
||||
Vec::new()
|
||||
@@ -743,6 +744,7 @@ fn log_indexed_rows(
|
||||
graph_parents: shown_parents,
|
||||
on_current_branch,
|
||||
history_path: history_paths.get(&id).cloned(),
|
||||
merge_time_secs: commit_time_secs,
|
||||
});
|
||||
if out.len() >= limit || stop_id == Some(id) {
|
||||
break;
|
||||
|
||||
@@ -125,6 +125,9 @@ pub struct Commit {
|
||||
pub log_position: Option<u32>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub log_total: Option<u32>,
|
||||
/// Newest committer time at or after this row if newer than the row's commit.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub log_merge_time_ms: Option<f64>,
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub graph_boundary_parents: Vec<String>,
|
||||
/// Reachability from HEAD, computed independently of the visible filters.
|
||||
|
||||
@@ -19,12 +19,16 @@ const MESSAGES: TableDefinition<&str, &str> = TableDefinition::new("messages-v1"
|
||||
const MAX_MEMORY_COMMITS: usize = 4096;
|
||||
const MAX_MEMORY_MESSAGES: usize = 1024;
|
||||
const MAX_DIRTY_BATCH: usize = 16_384;
|
||||
/// redb's page cache, which otherwise grows to 1 GiB per repository. Hot commits are already
|
||||
/// kept in `memory`.
|
||||
const DB_CACHE_BYTES: usize = 32 * 1024 * 1024;
|
||||
|
||||
pub(crate) struct IndexedRow {
|
||||
pub id: ObjectId,
|
||||
pub graph_parents: Vec<ObjectId>,
|
||||
pub on_current_branch: bool,
|
||||
pub history_path: Option<String>,
|
||||
pub merge_time_secs: i64,
|
||||
}
|
||||
|
||||
pub(crate) struct IndexedView {
|
||||
@@ -32,8 +36,15 @@ pub(crate) struct IndexedView {
|
||||
pub positions: HashMap<ObjectId, usize>,
|
||||
}
|
||||
impl IndexedView {
|
||||
pub fn new(rows: Vec<IndexedRow>) -> Self {
|
||||
let positions = rows.iter().enumerate().map(|(i, r)| (r.id, i)).collect();
|
||||
pub fn new(mut rows: Vec<IndexedRow>) -> Self {
|
||||
let mut positions = HashMap::with_capacity(rows.len());
|
||||
let mut latest = i64::MIN;
|
||||
// Compute priority across the whole log so it stays the same on every page.
|
||||
for (i, row) in rows.iter_mut().enumerate().rev() {
|
||||
latest = latest.max(row.merge_time_secs);
|
||||
row.merge_time_secs = latest;
|
||||
positions.insert(row.id, i);
|
||||
}
|
||||
Self { rows, positions }
|
||||
}
|
||||
}
|
||||
@@ -269,7 +280,11 @@ impl LogIndex {
|
||||
let path = dir.join("commits.redb");
|
||||
let mut databases = DATABASES.get_or_init(Mutex::default).lock().unwrap_or_else(|p| p.into_inner());
|
||||
self.db = databases.get(&path).and_then(Weak::upgrade).or_else(|| {
|
||||
let db = Arc::new(std::fs::create_dir_all(dir).ok().and_then(|_| Database::create(&path).ok())?);
|
||||
let db = Arc::new(
|
||||
std::fs::create_dir_all(dir)
|
||||
.ok()
|
||||
.and_then(|_| Database::builder().set_cache_size(DB_CACHE_BYTES).create(&path).ok())?,
|
||||
);
|
||||
drop_stale_tables(&db);
|
||||
databases.insert(path, Arc::downgrade(&db));
|
||||
Some(db)
|
||||
@@ -334,6 +349,7 @@ impl LogIndex {
|
||||
history_path: None,
|
||||
log_position: None,
|
||||
log_total: None,
|
||||
log_merge_time_ms: None,
|
||||
graph_boundary_parents: Vec::new(),
|
||||
refs: Vec::new(),
|
||||
});
|
||||
|
||||
@@ -83,6 +83,28 @@ fn incoming_order_groups_the_merged_branch_before_the_main_parent() {
|
||||
assert_eq!(out[1].parents, vec![h.c2.clone(), h.s1.clone()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_older_incoming_tip_uses_the_later_commit_time_when_merging_repo_pages() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let dir = tmp.path();
|
||||
git(dir, &["init", "-q"], None);
|
||||
let base = commit(dir, "base.txt", "base", 1000);
|
||||
let recent = commit(dir, "recent.txt", "recent", 4000);
|
||||
git(dir, &["checkout", "-qb", "incoming", &base], None);
|
||||
let incoming = commit(dir, "incoming.txt", "incoming", 2000);
|
||||
git(dir, &["checkout", "-q", "main"], None);
|
||||
let repo = Repo::discover(dir).unwrap().unwrap();
|
||||
let query = LogQuery { summary_only: true, order: LogOrder::Standard, limit: 1, ..Default::default() };
|
||||
|
||||
let first = repo.log(&query).unwrap();
|
||||
assert_eq!(first[0].id, incoming);
|
||||
assert_eq!(first[0].commit_time_ms, 2_000_000.0);
|
||||
assert_eq!(first[0].log_merge_time_ms, Some(4_000_000.0));
|
||||
let next = repo.log(&LogQuery { skip: 1, ..query }).unwrap();
|
||||
assert_eq!(next[0].id, recent);
|
||||
assert_eq!(next[0].log_merge_time_ms, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_merges_links_children_to_the_merge_parents() {
|
||||
let h = history();
|
||||
|
||||
@@ -86,6 +86,7 @@ Each crate's `lib.rs` opens with a module doc comment describing its contract; r
|
||||
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `ide-cli` | The `openidea` command: argument parsing, the request it sends to a running app over a local socket, installing it on `PATH`. |
|
||||
| `ide-clipboard` | The OS clipboard's file list (Windows `CF_HDROP`, macOS `NSPasteboard` file URLs) for copying files between the Project view and the file manager. |
|
||||
| `ide-drag-out` | OS file drags out of a window (GTK, OLE, AppKit), so files dragged from the Project view to another app are copied there. |
|
||||
| `ide-fonts` | Installed font families for the font pickers, via CoreText, DirectWrite or fontconfig. |
|
||||
| `src-tauri` (package `openidea`) | The desktop shell: `AppState`, Tauri commands, the event sink, windows, menus, the remote-development client, the `openidea-plugin` URL scheme for plugin web views. Glue only. |
|
||||
|
||||
|
||||
@@ -125,7 +125,7 @@ Tasks are saved per project and survive restarts. When the agent supports resumi
|
||||
|
||||
**Settings › Tools › Agents** (also **More Agents…** in the agent picker) has two tabs:
|
||||
|
||||
- **Built-in**: for each built-in agent, whether its executable was found on `PATH`, a field to point at a **Custom executable**, **Environment variables** for the agent process (written as `NAME=value; OTHER=value`; the values are kept in the OS credential store) and how to sign in. Changes apply to new sessions.
|
||||
- **Built-in**: for each built-in agent, whether its executable was found on `PATH`, a field to point at a **Custom executable**, **Environment variables** for the agent process (written as `NAME=value; OTHER=value`; the values are kept in the OS credential store) and how to sign in. Changes apply to new sessions. When the agent is a global npm install (such as Claude Code, Codex or Gemini CLI), **Check for updates** compares it with npm's latest stable release and **Update to…** updates that installation.
|
||||
- **ACP Registry**: agents published in the [ACP Registry](https://agentclientprotocol.com). Search, **Install**, **Update** and **Remove**. Installed agents are kept in OpenIDEA's data directory; downloads are checked against the registry's SHA-256 when it provides one.
|
||||
|
||||
**Settings › Tools › Agents › Chat** chooses what the task header shows: **Context window usage**, **Time spent on the task**, **Usage limits** (when the agent reports them, such as Claude Code) and **Session cost**.
|
||||
|
||||
@@ -57,6 +57,7 @@ Language servers that support LSP inline completion show a grey suggestion at th
|
||||
| **Next Method** / **Previous Method** | `⌃⇧↓` / `⌃⇧↑` | `Alt+Down` / `Alt+Up` |
|
||||
|
||||
- **Go to Declaration or Usages** on a declaration shows its usages instead.
|
||||
- **Go to Implementation(s)** navigates to the symbol's own declaration when it has no implementations, as in IntelliJ IDEA.
|
||||
- Hold `⌘` / `Ctrl` and hover over a name to see it underlined as a link, with brief information about it.
|
||||
- Gutter icons mark types and methods that are implemented or overridden (↓) and methods that implement or override another (↑). Click one to go there.
|
||||
- **Navigate › Test** jumps between a class and its tests by naming convention and offers **Create New Test…** when there is none.
|
||||
|
||||
@@ -172,11 +172,13 @@ The export button offers **Export Data…** and quick copies: **Copy as CSV**, *
|
||||
|
||||
The built-in HTTP driver uses a named session by default (`use_http_session=true`). Route requests to one node or enable session affinity. If the session expires or another node reports code 372, OpenIDEA shows a reconnect error and never replays the statement.
|
||||
|
||||
For endpoints that route each request to a different node, add **Advanced** property `use_http_session` with value `false`. Each request omits `session_id`, `session_check` and `session_timeout`, and sends the configured database (or **Default schema**), time zone and Advanced settings again. **Read-only** sends `readonly=1` on every request; result-limit settings remain enabled.
|
||||
For endpoints that route each request to a different node, add **Advanced** property `use_http_session` with value `false`. Each request omits `session_id`, `session_check` and `session_timeout`, and sends the configured database (or **Default schema**), time zone and Advanced settings again. **Read-only** sends `readonly=1` on every request.
|
||||
|
||||
Stateless statements must be independent: `USE`, standalone `SET`, temporary tables and other session state cannot carry over to later requests. Configure the database and settings on the data source. Startup scripts and explicit session properties (`session_id`, `session_check`, `session_timeout`) are rejected. SQL transactions and statement caching are unsupported in either mode.
|
||||
|
||||
Strict read-only servers that refuse per-request driver settings cannot use stateless mode: the connection fails without dropping read-only protection or limits. The strict read-only fallback requires proof in the same named HTTP session, including on subsequent requests; use one node or session affinity.
|
||||
For strict read-only accounts behind a load balancer, set `use_http_session=false` and enable **Read-only**. If the initial connection check receives ClickHouse code 164 for a driver-managed result setting, OpenIDEA repeats the check without its result-limit and JSON number-format settings. Each request still sends `readonly=1`, and the grid still retains only the requested page. Configure server-side limits in the account's settings profile. With the server's default JSON settings, `NaN` and infinities may appear as `NULL`.
|
||||
|
||||
Use consistent account profiles across replicas. If the first node accepts the driver's result settings and a later node rejects them, OpenIDEA reports the error on that request. Connect again after aligning the profiles.
|
||||
|
||||
## Oracle
|
||||
|
||||
|
||||
@@ -112,7 +112,7 @@ The debugger adds attach-only types such as **Remote JVM Debug**, **Go Remote**,
|
||||
### Common fields
|
||||
|
||||
- **Run on**: the local machine, or an SSH host defined in **Settings › Build, Execution, Deployment › Run Targets**. Debugging is not available on run targets. See [SSH](/en/guide/remote/ssh).
|
||||
- **Working directory**: relative to the project root; empty means the project root.
|
||||
- **Working directory**: relative to the project root; empty means the project root. It may use the path macros `$PROJECT_DIR$`, `$ContentRoot$`, `$MODULE_DIR$`, `$MODULE_WORKING_DIR$` and `$USER_HOME$`, expanded when the configuration starts, so a shared configuration works on every machine.
|
||||
- **Environment variables**: `VAR=value` pairs separated by `;`. The list button opens the **Environment Variables** dialog, where **Include system environment variables** can be turned off.
|
||||
- **Debug adapter**: which debugger **Debug** uses for this configuration (for example `debugpy`, `js-debug`, `codelldb`, `delve`).
|
||||
|
||||
|
||||
@@ -23,7 +23,7 @@ Only types you add appear here: choose **Add Service › Run Configuration Type*
|
||||
- Configuration actions: **Run** (or **Rerun**), **Debug**, **Stop**, **Open in Browser**, **Update Application** (for configurations that support it).
|
||||
- Context menu: **Show in Run Tool Window**, **Show in Debug Tool Window**, **Edit Configuration…**, **Remove from Services**.
|
||||
|
||||
A configuration that ran shows its console in the detail pane. Reorder configurations within a group by dragging them or with **Move Up** / **Move Down**; the order is saved per project.
|
||||
A configuration that ran shows its console in the detail pane; one debugged from here shows the whole debugger there (Threads & Variables, Console, Memory), and a breakpoint keeps the Services tool window in front. Reorder configurations within a group by dragging them or with **Move Up** / **Move Down**; the order is saved per project.
|
||||
|
||||
## Docker
|
||||
|
||||
|
||||
@@ -86,6 +86,7 @@ Cargo workspace 由 `crates/*` 加 `src-tauri` 组成(见根目录 `Cargo.toml
|
||||
| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `ide-cli` | `openidea` 命令:参数解析、通过本地 socket 发给运行中应用的请求、安装到 `PATH`。 |
|
||||
| `ide-clipboard` | 操作系统剪贴板里的文件列表(Windows `CF_HDROP`、macOS `NSPasteboard` 文件 URL),用于 Project 视图与文件管理器之间复制文件。 |
|
||||
| `ide-drag-out` | 从窗口发起操作系统文件拖放(GTK、OLE、AppKit),从 Project 视图拖到其他程序的文件由该程序复制。 |
|
||||
| `ide-fonts` | 已安装的字体族,供字体选择器使用,分别通过 CoreText、DirectWrite 或 fontconfig 获取。 |
|
||||
| `src-tauri`(包名 `openidea`) | 桌面外壳:`AppState`、Tauri 命令、事件 sink、窗口、菜单、远程开发客户端、插件 Web 视图用的 `openidea-plugin` URL scheme。只做胶水。 |
|
||||
|
||||
|
||||
@@ -125,7 +125,7 @@ agent 运行过一个任务后,新任务会以它自动批准所有操作的
|
||||
|
||||
**设置 › 工具 › 智能体**(也可以在 agent 选择器中点 **更多 Agent…**)有两个标签页:
|
||||
|
||||
- **内置**:每个内置 agent 的可执行文件是否在 `PATH` 中找到、指定 **自定义可执行文件** 的输入框、传给 agent 进程的 **环境变量**(格式为 `NAME=value; OTHER=value`;这些值保存在系统凭据存储中)以及登录方式。改动对新会话生效。
|
||||
- **内置**:每个内置 agent 的可执行文件是否在 `PATH` 中找到、指定 **自定义可执行文件** 的输入框、传给 agent 进程的 **环境变量**(格式为 `NAME=value; OTHER=value`;这些值保存在系统凭据存储中)以及登录方式。改动对新会话生效。如果 agent 是 npm 全局安装(例如 Claude Code、Codex、Gemini CLI),**检查更新** 会与 npm 的最新稳定版比较,点击 **更新至…** 即可更新这份安装。
|
||||
- **ACP 注册表**:[ACP Registry](https://agentclientprotocol.com) 中发布的 agent,可以搜索、**安装**、**更新** 和 **移除**。安装的 agent 保存在 OpenIDEA 的数据目录中;注册表提供 SHA-256 时会校验下载内容。
|
||||
|
||||
**设置 › 工具 › 智能体 › 聊天** 决定任务标题栏显示哪些信息:**上下文窗口用量**、**任务耗时**、**用量限额**(agent 报告时,例如 Claude Code)和 **会话花费**。
|
||||
|
||||
@@ -57,6 +57,7 @@ description: "代码补全、导航、查找用法、文档、层次结构与文
|
||||
| **下一个方法** / **上一个方法** | `⌃⇧↓` / `⌃⇧↑` | `Alt+Down` / `Alt+Up` |
|
||||
|
||||
- 在声明本身上执行 **转到声明或用法**,会改为显示它的用法。
|
||||
- 没有任何实现时,**转到实现** 会跳转到符号自身的声明,与 IntelliJ IDEA 一致。
|
||||
- 按住 `⌘` / `Ctrl` 把鼠标悬停在名称上,名称会显示为链接,并附带简要信息。
|
||||
- 装订区域的图标标出被实现或被重写的类型和方法(↓),以及实现或重写了其他方法的方法(↑),单击即可跳转。
|
||||
- **导航 › 测试** 按命名约定在类和它的测试之间跳转;还没有测试时会提供 **创建新测试…**。
|
||||
|
||||
@@ -171,11 +171,13 @@ SQL 补全基于已连接的架构:`FROM`/`JOIN` 后补全表(并根据外
|
||||
|
||||
内置 HTTP 驱动默认使用命名会话(`use_http_session=true`)。请求应路由到同一节点,或启用会话亲和性。如果会话过期或其他节点返回代码 372,OpenIDEA 会提示重新连接,且不会重放语句。
|
||||
|
||||
如果端点把每个请求路由到不同节点,可在 **高级** 中添加属性 `use_http_session`,值设为 `false`。每个请求都省略 `session_id`、`session_check` 和 `session_timeout`,并重新发送配置的数据库(或 **默认架构**)、时区及高级设置。启用 **只读** 时,每个请求都发送 `readonly=1`;结果行数限制设置也会保留。
|
||||
如果端点把每个请求路由到不同节点,可在 **高级** 中添加属性 `use_http_session`,值设为 `false`。每个请求都省略 `session_id`、`session_check` 和 `session_timeout`,并重新发送配置的数据库(或 **默认架构**)、时区及高级设置。启用 **只读** 时,每个请求都发送 `readonly=1`。
|
||||
|
||||
无会话模式下,每条语句必须独立:`USE`、独立的 `SET`、临时表及其他会话状态无法延续到后续请求。请在数据源中配置数据库和设置。驱动会拒绝启动脚本以及显式会话属性(`session_id`、`session_check`、`session_timeout`)。两种模式均不支持 SQL 事务和语句缓存。
|
||||
|
||||
拒绝逐请求驱动设置的严格只读服务器无法使用无会话模式:连接会失败,不会移除只读保护或限制。严格只读回退必须在同一个命名 HTTP 会话中验证,后续请求也必须使用该会话;请使用单一节点或会话亲和性。
|
||||
对于负载均衡器后的严格只读账户,请设置 `use_http_session=false` 并启用 **只读**。如果初次连接检查因驱动管理的结果设置收到 ClickHouse 错误码 164,OpenIDEA 会省略驱动的结果行数限制和 JSON 数字格式设置,再进行一次连接检查。每个请求仍会发送 `readonly=1`,结果表格仍只保留所请求的一页。请在账户的设置配置文件中配置服务端限制。使用服务器的默认 JSON 设置时,`NaN` 和无穷值可能显示为 `NULL`。
|
||||
|
||||
请在各副本上使用一致的账户设置配置文件。如果第一个节点接受驱动的结果设置,后续节点拒绝这些设置,OpenIDEA 会报告该请求的错误。调整配置文件使其一致后再连接。
|
||||
|
||||
## Oracle
|
||||
|
||||
|
||||
@@ -108,7 +108,7 @@ description: "创建、编辑和启动运行配置,从装订区运行代码,
|
||||
### 通用字段
|
||||
|
||||
- **运行于**:本地计算机,或在 **设置 › 构建、执行、部署 › 运行目标** 中添加的 SSH 主机。运行目标上不支持调试。参见 [SSH](/zh/guide/remote/ssh)。
|
||||
- **工作目录**:相对于项目根目录,留空即项目根目录。
|
||||
- **工作目录**:相对于项目根目录,留空即项目根目录。可以使用路径宏 `$PROJECT_DIR$`、`$ContentRoot$`、`$MODULE_DIR$`、`$MODULE_WORKING_DIR$` 和 `$USER_HOME$`,在配置启动时展开,因此共享的配置在每台机器上都能用。
|
||||
- **环境变量**:`VAR=value` 形式,用 `;` 分隔。点旁边的列表按钮打开“环境变量”对话框,可以关闭 **包括系统环境变量**。
|
||||
- **调试适配器**:按“调试”时这个配置使用哪个调试器(如 `debugpy`、`js-debug`、`codelldb`、`delve`)。
|
||||
|
||||
|
||||
@@ -23,7 +23,7 @@ description: "在服务工具窗口中管理运行配置、Docker 容器、镜
|
||||
- 配置操作:**运行**(或 **重新运行**)、**调试**、**停止**、**在浏览器中打开**、**更新应用**(仅支持的配置)。
|
||||
- 右键菜单:**在运行工具窗口中显示**、**在调试工具窗口中显示**、**编辑配置…**、**从服务中移除**。
|
||||
|
||||
运行过的配置会在详情区显示其控制台。在同一分组内可以拖动或用 **上移** / **下移** 调整顺序,顺序按项目保存。
|
||||
运行过的配置会在详情区显示其控制台;从这里调试的配置在详情区显示完整的调试器(线程和变量、控制台、内存),命中断点时停留在服务工具窗口。在同一分组内可以拖动或用 **上移** / **下移** 调整顺序,顺序按项目保存。
|
||||
|
||||
## Docker
|
||||
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
import type { AgentEntry, AgentTask } from "../src/bindings";
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
const first: AgentTask = {
|
||||
id: "context-first",
|
||||
title: "First conversation",
|
||||
provider: "codex",
|
||||
status: "ready",
|
||||
isolation: "local",
|
||||
model: null,
|
||||
cwd: "/dev/acme-api",
|
||||
branch: null,
|
||||
base: null,
|
||||
baseCommit: null,
|
||||
error: null,
|
||||
createdMs: 0,
|
||||
updatedMs: 0,
|
||||
config: [],
|
||||
commands: [],
|
||||
usage: null,
|
||||
queue: [],
|
||||
};
|
||||
const second: AgentTask = { ...first, id: "context-second", title: "Second conversation" };
|
||||
|
||||
for (const active of ["conversation", "file"] as const) {
|
||||
test(`an agent context menu keeps the current ${active} open`, async ({ workbench: page }) => {
|
||||
await page.getByRole("treeitem", { name: "README.md", exact: true }).dblclick();
|
||||
await expect(page.getByRole("tab", { name: "README.md", exact: true })).toBeVisible();
|
||||
await page.evaluate(
|
||||
async ({ first, second }) => {
|
||||
const storePath = "/src/features/agents/store.ts";
|
||||
const ipcPath = "/src/platform/ipc.ts";
|
||||
const contributionsPath = "/src/workbench/contributions.ts";
|
||||
const store = await import(storePath);
|
||||
const { commands } = await import(ipcPath);
|
||||
const { toolWindowService } = await import(contributionsPath);
|
||||
commands.agentChanges = async () => ({ status: "ok", data: [] });
|
||||
const entries: AgentEntry[] = [{ type: "agent", text: "The active conversation stays here." }];
|
||||
store.useAgents.setState({
|
||||
loaded: true,
|
||||
error: null,
|
||||
providers: [],
|
||||
tasks: new Map([
|
||||
[first.id, first],
|
||||
[second.id, second],
|
||||
]),
|
||||
entries: new Map([
|
||||
[first.id, entries],
|
||||
[second.id, []],
|
||||
]),
|
||||
composers: new Map([[first.id, { text: "Keep this unsent draft", files: [], images: [] }]]),
|
||||
unread: new Set(),
|
||||
docked: null,
|
||||
homeOpen: false,
|
||||
sessionLocation: "editor",
|
||||
});
|
||||
toolWindowService().show("agents", true);
|
||||
store.openTask(first.id);
|
||||
},
|
||||
{ first, second },
|
||||
);
|
||||
const firstTab = page.getByRole("tab", { name: first.title, exact: true });
|
||||
const fileTab = page.getByRole("tab", { name: "README.md", exact: true });
|
||||
await expect(firstTab).toHaveAttribute("aria-selected", "true");
|
||||
if (active === "file") await fileTab.click();
|
||||
const current = active === "file" ? fileTab : firstTab;
|
||||
const target = page.getByRole("tree", { name: "Agent tasks" }).getByText(second.title, { exact: true });
|
||||
await target.click({ button: "right" });
|
||||
await expect(page.getByRole("menuitem", { name: "Rename…", exact: true })).toBeVisible();
|
||||
await expect(current).toHaveAttribute("aria-selected", "true");
|
||||
await expect(page.getByRole("tab", { name: second.title, exact: true })).toHaveCount(0);
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(current).toHaveAttribute("aria-selected", "true");
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(async (id) => {
|
||||
const storePath = "/src/features/agents/store.ts";
|
||||
return (await import(storePath)).composerDraft(id).text;
|
||||
}, first.id),
|
||||
)
|
||||
.toBe("Keep this unsent draft");
|
||||
await target.click();
|
||||
await expect(page.getByRole("tab", { name: second.title, exact: true })).toHaveAttribute("aria-selected", "true");
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
import { expect, openFromTree, test } from "./fixtures";
|
||||
|
||||
test("code folding controls stay grouped in narrow settings", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Code Folding");
|
||||
await dialog.getByRole("treeitem", { name: "Code Folding", exact: true }).click();
|
||||
|
||||
const label = "Show code folding outline";
|
||||
const outline = dialog.getByRole("checkbox", { name: label, exact: true });
|
||||
const visibility = dialog.getByRole("button", { name: label, exact: true });
|
||||
const defaults = dialog.getByRole("region", { name: "Fold by default:", exact: true });
|
||||
await expect(visibility).toHaveText("On hover");
|
||||
const wideOutline = (await outline.boundingBox())!;
|
||||
expect((await visibility.boundingBox())!.x).toBeGreaterThan(wideOutline.x + wideOutline.width);
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
await expect(visibility).toBeInViewport({ ratio: 0.98 });
|
||||
const rows = await Promise.all(
|
||||
["File header", "Imports", "Documentation comments"].map((name) =>
|
||||
defaults.getByRole("checkbox", { name, exact: true }).boundingBox(),
|
||||
),
|
||||
);
|
||||
expect(rows[0]!.x).toBe(rows[2]!.x);
|
||||
expect(rows[0]!.y).toBeLessThan(rows[1]!.y);
|
||||
expect(rows[1]!.y).toBeLessThan(rows[2]!.y);
|
||||
|
||||
await outline.uncheck();
|
||||
await expect(dialog.getByRole("textbox", { name: label, exact: true })).toBeDisabled();
|
||||
await expect(defaults.getByRole("checkbox", { name: "Imports", exact: true })).toBeEnabled();
|
||||
});
|
||||
|
||||
test("folding visibility applies to an already open editor and keeps folded arrows visible", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const editor = await openFromTree(page, "App.tsx");
|
||||
const content = editor.locator(".cm-content");
|
||||
await content.click();
|
||||
await page.keyboard.press("Meta+a");
|
||||
await page.keyboard.insertText("export function sum() {\n return 1 + 2;\n}\n");
|
||||
const arrow = editor.locator(".cm-foldGutter .cm-openidea-foldOpen").first();
|
||||
await expect(arrow).toHaveCSS("opacity", "0");
|
||||
|
||||
const openSettings = async () => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Code Folding");
|
||||
await dialog.getByRole("treeitem", { name: "Code Folding", exact: true }).click();
|
||||
return dialog;
|
||||
};
|
||||
const label = "Show code folding outline";
|
||||
const settings = await openSettings();
|
||||
await settings.getByRole("button", { name: label, exact: true }).click();
|
||||
await page.getByRole("option", { name: "Always", exact: true }).click();
|
||||
await settings.getByRole("button", { name: "OK", exact: true }).click();
|
||||
await content.hover();
|
||||
await expect(arrow).toHaveCSS("opacity", "1");
|
||||
|
||||
const reopened = await openSettings();
|
||||
const control = reopened.getByRole("button", { name: label, exact: true });
|
||||
await expect(control).toHaveText("Always");
|
||||
await control.click();
|
||||
await page.getByRole("option", { name: "On hover", exact: true }).click();
|
||||
await reopened.getByRole("button", { name: "OK", exact: true }).click();
|
||||
await content.hover();
|
||||
await expect(arrow).toHaveCSS("opacity", "0");
|
||||
await arrow.click();
|
||||
await content.hover();
|
||||
await expect(editor.locator(".cm-foldGutter .cm-openidea-foldClosed").first()).toHaveCSS("opacity", "1");
|
||||
await expect(editor.locator(".cm-foldPlaceholder").first()).toBeVisible();
|
||||
});
|
||||
@@ -60,7 +60,21 @@ test("completion lists the server's items and inserts the chosen one", async ({
|
||||
await editor.locator(".cm-line", { hasText: "return order.toDto()" }).click();
|
||||
await page.keyboard.press("End");
|
||||
await page.keyboard.press("Enter");
|
||||
await page.keyboard.type("order.");
|
||||
await page.keyboard.type("order");
|
||||
const firstPlacement = await page.evaluateHandle(() => {
|
||||
const sample: { labelX?: number } = {};
|
||||
const observer = new MutationObserver(() => {
|
||||
const label = document.querySelector(
|
||||
":is(.cm-tooltip-above, .cm-tooltip-below).cm-lsp-completion .cm-completionLabel",
|
||||
);
|
||||
if (!label) return;
|
||||
sample.labelX = label.getBoundingClientRect().left;
|
||||
observer.disconnect();
|
||||
});
|
||||
observer.observe(document.body, { subtree: true, attributes: true, attributeFilter: ["class"] });
|
||||
return sample;
|
||||
});
|
||||
await page.keyboard.type(".");
|
||||
await page.keyboard.press("Control+Space");
|
||||
const popup = page.locator(".cm-tooltip-autocomplete");
|
||||
await expect(popup.getByText("total", { exact: true })).toBeVisible();
|
||||
@@ -83,6 +97,8 @@ test("completion lists the server's items and inserts the chosen one", async ({
|
||||
});
|
||||
const label = await method.locator(".cm-completionLabel").boundingBox();
|
||||
// Subpixel rounding differs per platform/font; a mis-set inset is a whole icon column off.
|
||||
const firstLabelX = await firstPlacement.evaluate((sample) => sample.labelX!);
|
||||
expect(Math.abs(firstLabelX - wordStart)).toBeLessThanOrEqual(2);
|
||||
expect(Math.abs(label!.x - wordStart)).toBeLessThanOrEqual(2);
|
||||
const zoomedSize = await editor.locator(".cm-content").evaluate(async (content) => {
|
||||
const viewModule = "/node_modules/.vite/deps/@codemirror_view.js";
|
||||
|
||||
@@ -4,7 +4,7 @@ for (const [id, selector] of [
|
||||
["general", "[class*='radios'] label"],
|
||||
["notifications", "table tbody td:first-child"],
|
||||
["keymap", "[class*='presetLabel']"],
|
||||
["editor.inspections", "[class*='profileRow'] > span:first-child"],
|
||||
["editor.inspections", "[class*='profileControls'] > span:first-child"],
|
||||
["vcs.issueNavigation", "[class*='pageBody'] button:not([aria-label])"],
|
||||
] as const) {
|
||||
test(`${id} keeps compact labels inside their controls`, async ({ workbench: page }) => {
|
||||
|
||||
@@ -0,0 +1,72 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Coverage keeps sortable statistics aligned next to the file tree at sidebar widths", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 1050, height: 550 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(async () => {
|
||||
const projectModule = "/src/platform/project.ts";
|
||||
const actionsModule = "/src/platform/actions.ts";
|
||||
const layoutModule = "/src/workbench/toolwindows/store.ts";
|
||||
const { useProject } = await import(/* @vite-ignore */ projectModule);
|
||||
const { executeAction } = await import(/* @vite-ignore */ actionsModule);
|
||||
const { setToolWindowSize } = await import(/* @vite-ignore */ layoutModule);
|
||||
const root = useProject.getState().project.root;
|
||||
const files = Array.from({ length: 36 }, (_, i) => ({
|
||||
path: root + (i === 0 ? "/src/Ready.ts" : i === 1 ? "/src/Uncovered.ts" : "/src/settlement/Report" + i + ".ts"),
|
||||
lines: [],
|
||||
linesCovered: i === 0 ? 20 : i,
|
||||
linesTotal: i === 0 ? 20 : 60,
|
||||
branchesCovered: i === 0 ? 4 : 1,
|
||||
branchesTotal: 4,
|
||||
}));
|
||||
window.__ipc.handlers.coverage_import = ({ path }) => ({
|
||||
runner: "lcov",
|
||||
hasBranches: path === "/tmp/coverage.lcov",
|
||||
files,
|
||||
});
|
||||
setToolWindowSize("right", 280);
|
||||
await executeAction("coverage.importReport", "/tmp/coverage.lcov");
|
||||
});
|
||||
|
||||
const coverage = page.getByRole("region", { name: "Coverage", exact: true });
|
||||
const tree = coverage.getByRole("tree", { name: "Coverage" });
|
||||
const line = coverage.getByRole("columnheader", { name: "Line, %" });
|
||||
const branch = coverage.getByRole("columnheader", { name: "Branch, %" });
|
||||
const folder = tree.getByRole("treeitem", { name: /^settlement/ });
|
||||
const ready = tree.getByRole("treeitem", { name: /^Ready\.ts/ });
|
||||
await expect(ready).toBeVisible();
|
||||
await expect(branch).toBeInViewport({ ratio: 1 });
|
||||
await expect.poll(() => tree.evaluate((element) => element.scrollWidth - element.clientWidth)).toBe(0);
|
||||
|
||||
const lineLeft = (await line.boundingBox())!.x;
|
||||
const branchLeft = (await branch.boundingBox())!.x;
|
||||
for (const row of [ready, folder]) {
|
||||
const cells = await row.getByTitle(/% \(/).all();
|
||||
expect(cells).toHaveLength(2);
|
||||
expect((await cells[0]!.boundingBox())!.x).toBeCloseTo(lineLeft, 0);
|
||||
expect((await cells[1]!.boundingBox())!.x).toBeCloseTo(branchLeft, 0);
|
||||
}
|
||||
|
||||
await branch.click();
|
||||
await expect(branch).toHaveAttribute("aria-sort", "descending");
|
||||
await expect(tree.getByRole("treeitem").nth(1)).toHaveAccessibleName(/^Ready\.ts/);
|
||||
await folder.locator("[data-tree-toggle]").click();
|
||||
const nested = tree.getByRole("treeitem", { name: /^Report/ }).first();
|
||||
await expect(nested).toBeVisible();
|
||||
expect(await tree.evaluate((element) => element.scrollHeight)).toBeGreaterThan(
|
||||
await tree.evaluate((element) => element.clientHeight),
|
||||
);
|
||||
expect((await nested.getByTitle("25% (1/4)").boundingBox())!.x).toBeCloseTo((await branch.boundingBox())!.x, 0);
|
||||
expect((await nested.getByTitle(/^Report/).boundingBox())!.width).toBeGreaterThan(30);
|
||||
|
||||
await page.evaluate(async () => {
|
||||
const actionsModule = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ actionsModule);
|
||||
await executeAction("coverage.importReport", "/tmp/lines.lcov");
|
||||
});
|
||||
await expect(branch).toHaveCount(0);
|
||||
await expect(line).toBeVisible();
|
||||
expect((await ready.getByTitle("100% (20/20)").boundingBox())!.x).toBeCloseTo((await line.boundingBox())!.x, 0);
|
||||
});
|
||||
@@ -0,0 +1,66 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("long diagnostics and quick fixes wrap within a narrow editor hover", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 520, height: 580 });
|
||||
const path = "/dev/acme-api/Settlement.ts";
|
||||
const identifier = "QuarterlyCrossBorderSettlementProjection".repeat(4);
|
||||
const message = `Cannot resolve ${identifier}.\nCheck the settlement calculation.`;
|
||||
const title = `Replace with ${identifier}Result`;
|
||||
const range = { start: { line: 0, col: 0 }, end: { line: 0, col: 7 } };
|
||||
await page.evaluate(async (path) => {
|
||||
const backend = "/src/editor/core/backend.ts";
|
||||
(await import(/* @vite-ignore */ backend)).docBackend().files.set(path, "pending();\n");
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile(path);
|
||||
}, path);
|
||||
await expect(page.locator(".cm-content")).toContainText("pending()");
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ path, message, title, range }) => {
|
||||
window.__ipc.handlers.lsp_hover = () => null;
|
||||
window.__ipc.handlers.lsp_code_actions = () => [
|
||||
{
|
||||
title,
|
||||
kind: "quickfix",
|
||||
isPreferred: true,
|
||||
disabledReason: null,
|
||||
edit: {
|
||||
files: [{ kind: "edit", path, edits: [{ range, new_text: "settled" }] }],
|
||||
},
|
||||
command: null,
|
||||
data: null,
|
||||
server: 1,
|
||||
},
|
||||
];
|
||||
const diagnostic = "/src/editor/lsp/diagnostics.ts";
|
||||
(await import(/* @vite-ignore */ diagnostic)).setFileDiagnostics(path, "settlement-lint", [
|
||||
{ severity: "error", message, range, source: "settlement-lint", code: "missing-model" },
|
||||
{ severity: "hint", message: "Review the reported total.", range, source: "settlement-lint", code: "review" },
|
||||
]);
|
||||
},
|
||||
{ path, message, title, range },
|
||||
);
|
||||
|
||||
await page.locator(".cm-content .cm-lintRange-error").hover();
|
||||
const hover = page.locator(".cm-lsp-hover");
|
||||
await expect(hover).toBeVisible();
|
||||
const fix = hover.getByRole("button", { name: new RegExp(`^${title}`) });
|
||||
await expect(fix).toBeVisible();
|
||||
expect(await hover.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
const messageText = hover.locator(".cm-lsp-diag-message").first();
|
||||
await expect(messageText).toHaveText(message);
|
||||
await expect(messageText).toHaveCSS("font-size", "13px");
|
||||
const shortcut = fix.locator(".cm-lsp-diag-shortcut");
|
||||
await expect(shortcut).toBeVisible();
|
||||
await expect(shortcut).toHaveCSS("font-size", "12px");
|
||||
const more = hover.getByRole("button", { name: "More actions…", exact: true }).first();
|
||||
await expect(more).toBeInViewport({ ratio: 1 });
|
||||
const outer = (await hover.boundingBox())!;
|
||||
const action = (await fix.boundingBox())!;
|
||||
const editor = (await page.locator(".cm-editor").boundingBox())!;
|
||||
expect(outer.x + outer.width).toBeLessThanOrEqual(editor.x + editor.width + 1);
|
||||
expect(action.x + action.width).toBeLessThanOrEqual(outer.x + outer.width);
|
||||
await more.click();
|
||||
const intentions = page.getByRole("dialog", { name: "Intentions", exact: true });
|
||||
await expect(intentions.getByRole("option", { name: title })).toBeVisible();
|
||||
});
|
||||
@@ -406,6 +406,48 @@ test("Markdown preview highlights ⌘F matches, selected words and scales diagra
|
||||
expect(reset.excalidraw).toBeCloseTo(base.excalidraw, 1);
|
||||
});
|
||||
|
||||
test("Markdown preview keeps following find and edits after scrolling the source", async ({ workbench: page }) => {
|
||||
const editor = await openFromTree(page, "README.md");
|
||||
const content = editor.locator(".cm-content");
|
||||
const preview = page.getByRole("document", { name: "Markdown preview" });
|
||||
await content.click();
|
||||
await page.keyboard.press("Meta+a");
|
||||
const spacer = Array.from({ length: 90 }, (_, i) => `Paragraph ${i}.`).join("\n\n");
|
||||
await page.keyboard.insertText(`First needle\n\n${spacer}\n\nSecond needle\n\n${spacer}\n\nThird needle`);
|
||||
await content.press("Control+Home");
|
||||
await expect(preview).toContainText("Third needle");
|
||||
await editor.locator(".cm-scroller").evaluate((el) => (el.scrollTop = 2000));
|
||||
await expect.poll(() => preview.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
|
||||
await preview.focus();
|
||||
await page.keyboard.press("Meta+f");
|
||||
const find = page.getByRole("textbox", { name: "Find" });
|
||||
await find.fill("needle");
|
||||
const visibleMatch = () =>
|
||||
preview.evaluate((el) => {
|
||||
const match = (CSS.highlights.get("markdown-find-current") as unknown as Set<Range> | undefined)
|
||||
?.values()
|
||||
.next().value;
|
||||
if (!match) return null;
|
||||
const box = el.getBoundingClientRect();
|
||||
const range = match.getBoundingClientRect();
|
||||
return range.top >= box.top && range.bottom <= box.bottom ? match.startContainer.textContent : null;
|
||||
});
|
||||
await expect.poll(visibleMatch).toBe("First needle");
|
||||
await find.press("ArrowDown");
|
||||
await expect.poll(visibleMatch).toBe("Second needle");
|
||||
await find.press("ArrowDown");
|
||||
await expect.poll(visibleMatch).toBe("Third needle");
|
||||
await find.press("ArrowUp");
|
||||
await expect.poll(visibleMatch).toBe("Second needle");
|
||||
|
||||
await find.press("Escape");
|
||||
await content.focus();
|
||||
await page.keyboard.press("Meta+a");
|
||||
await page.keyboard.insertText("- **$`v_0`$ Flat wings.**");
|
||||
await expect(preview.locator("strong .katex annotation")).toHaveText("v_0");
|
||||
});
|
||||
|
||||
test("Markdown preview aligns Mermaid diagrams to their container align attribute", async ({ workbench: page }) => {
|
||||
const editor = await openFromTree(page, "README.md");
|
||||
const content = editor.locator(".cm-content");
|
||||
@@ -624,12 +666,24 @@ test("dragging the Markdown split divider resizes and reflows editor and preview
|
||||
const box = (await handle.boundingBox())!;
|
||||
const startX = box.x + box.width / 2;
|
||||
const midY = box.y + box.height / 2;
|
||||
const cursorAt = (x: number) =>
|
||||
page.evaluate(({ x, y }) => getComputedStyle(document.elementFromPoint(x, y)!).cursor, { x, y: midY });
|
||||
|
||||
await page.mouse.move(startX + 40, midY);
|
||||
await page.mouse.move(startX, midY);
|
||||
expect(await cursorAt(startX)).toMatch(/resize$/);
|
||||
await page.mouse.move(startX - 5, midY);
|
||||
expect(await cursorAt(startX - 5)).not.toMatch(/resize$/);
|
||||
|
||||
await page.mouse.move(startX, midY);
|
||||
await page.mouse.down();
|
||||
await page.mouse.move(startX - 180, midY, { steps: 6 });
|
||||
await expect(handle).toHaveAttribute("data-separator", "active");
|
||||
const sourceX = (await editor.boundingBox())!.x + 60;
|
||||
expect(await cursorAt(sourceX)).toMatch(/resize$/);
|
||||
await page.mouse.up();
|
||||
await page.mouse.move(sourceX, midY);
|
||||
expect(await cursorAt(sourceX)).toBe("text");
|
||||
|
||||
await expect.poll(async () => (await editor.boundingBox())!.width).toBeLessThan(initialEditor - 150);
|
||||
await expect.poll(async () => (await preview.boundingBox())!.width).toBeGreaterThan(initialPreview + 150);
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test.beforeEach(async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
await expect(page.getByRole("dialog", { name: "Settings", exact: true })).toBeVisible();
|
||||
await page.evaluate(async () => {
|
||||
const path = "/src/features/settings/model/staging.ts";
|
||||
(await import(/* @vite-ignore */ path)).selectPage("editor.fileTemplates");
|
||||
});
|
||||
});
|
||||
|
||||
test("file template fields and editors fit in narrow settings", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
const tabs = page.getByRole("tablist", { name: "Template kinds" });
|
||||
const name = page.getByRole("textbox", { name: "Template name" });
|
||||
const extension = page.getByRole("textbox", { name: "Extension" });
|
||||
const style = page.getByRole("button", { name: "File name style" });
|
||||
const body = page.getByRole("textbox", { name: "Template body", exact: true });
|
||||
|
||||
await expect(body).toBeInViewport({ ratio: 0.98 });
|
||||
expect((await body.boundingBox())!.width).toBeGreaterThan(150);
|
||||
await expect(extension).toBeInViewport({ ratio: 0.98 });
|
||||
await expect(style).toBeInViewport({ ratio: 0.98 });
|
||||
expect((await extension.boundingBox())!.y).toBeGreaterThan((await name.boundingBox())!.y);
|
||||
expect((await style.boundingBox())!.y).toBeGreaterThan((await extension.boundingBox())!.y);
|
||||
await style.click();
|
||||
await expect(page.getByRole("option", { name: "PascalCase" })).toBeVisible();
|
||||
await page.keyboard.press("Escape");
|
||||
|
||||
for (const [tab, editorName] of [
|
||||
["Includes", "Include body"],
|
||||
["Code", "Code template body"],
|
||||
]) {
|
||||
await tabs.getByRole("tab", { name: tab, exact: true }).click();
|
||||
await expect(page.getByRole("textbox", { name: editorName, exact: true })).toBeInViewport({ ratio: 0.98 });
|
||||
}
|
||||
});
|
||||
|
||||
test("file template tabs share a remembered, keyboard-adjustable divider", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1100, height: 760 });
|
||||
const tabs = page.getByRole("tablist", { name: "Template kinds" });
|
||||
const name = page.getByRole("textbox", { name: "Template name" });
|
||||
const extension = page.getByRole("textbox", { name: "Extension" });
|
||||
const divider = page.getByRole("separator", { name: "Resize file template panes" });
|
||||
const width = async (listName: string) =>
|
||||
(await page.getByRole("listbox", { name: listName, exact: true }).boundingBox())!.width;
|
||||
|
||||
await expect(divider).toBeVisible();
|
||||
expect((await extension.boundingBox())!.y).toBe((await name.boundingBox())!.y);
|
||||
const initial = await width("File templates");
|
||||
await divider.press("ArrowRight");
|
||||
await expect.poll(() => width("File templates")).toBeGreaterThan(initial + 10);
|
||||
const resized = await width("File templates");
|
||||
|
||||
await tabs.getByRole("tab", { name: "Files", exact: true }).press("ArrowRight");
|
||||
await expect(tabs.getByRole("tab", { name: "Includes", exact: true })).toBeFocused();
|
||||
await expect.poll(() => width("Includes")).toBeCloseTo(resized, 0);
|
||||
await page.getByRole("button", { name: "Add Include" }).click();
|
||||
const include = page.getByRole("textbox", { name: "Include body" });
|
||||
await include.fill("// Shared header");
|
||||
|
||||
await tabs.getByRole("tab", { name: "Code", exact: true }).click();
|
||||
await expect.poll(() => width("Code templates")).toBeCloseTo(resized, 0);
|
||||
await tabs.getByRole("tab", { name: "Includes", exact: true }).click();
|
||||
await page.getByRole("option", { name: "New Include", exact: true }).click();
|
||||
await expect(include).toHaveValue("// Shared header");
|
||||
});
|
||||
@@ -0,0 +1,75 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("an inline change keeps its actions and original code readable at the editor zoom", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 445, height: 520 });
|
||||
await stubDesktop(page);
|
||||
const original = "const routingPolicy = 'use the legacy regional settlement cutoff before reconciliation';";
|
||||
const current = "const routingPolicy = 'use the current policy';";
|
||||
const content = Array.from({ length: 22 }, (_, i) => {
|
||||
if (i === 4) return current;
|
||||
if (i === 11) return "const settlementWindow = 12;";
|
||||
return `// context ${i + 1}`;
|
||||
}).join("\n");
|
||||
|
||||
await page.evaluate(async (text) => {
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
window.__ipc.handlers.fs_probe = () => ({ size: text.length, binary: false, tooLarge: false });
|
||||
window.__ipc.handlers.fs_read_text = () => text;
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile("/dev/acme-api/settlement.ts");
|
||||
}, content);
|
||||
const editor = page.locator(".cm-editor");
|
||||
await expect(editor.locator(".cm-content")).toBeVisible();
|
||||
|
||||
await editor.evaluate(
|
||||
async (el, { original, content }) => {
|
||||
const { view } = (el.querySelector(".cm-content") as HTMLElement & { cmTile: { view: EditorView } }).cmTile;
|
||||
view.dom.style.setProperty("--openidea-editor-font-size", "18px");
|
||||
view.dispatch({ changes: { from: 0, to: view.state.doc.length, insert: content }, selection: { anchor: 0 } });
|
||||
window.__ipc.handlers.vcs_line_hunks = () => [
|
||||
{ kind: "modified", start: 4, lines: 1, oldStart: 4, oldLines: 1, oldText: original + "\n" },
|
||||
{ kind: "added", start: 11, lines: 1, oldStart: 11, oldLines: 0, oldText: "" },
|
||||
{ kind: "deleted", start: 15, lines: 0, oldStart: 14, oldLines: 1, oldText: "// obsolete window\n" },
|
||||
];
|
||||
const storeModule = "/src/features/vcs/store.ts";
|
||||
const { useVcs } = await import(/* @vite-ignore */ storeModule);
|
||||
useVcs.setState({ available: true, version: useVcs.getState().version + 1 });
|
||||
},
|
||||
{ original, content },
|
||||
);
|
||||
await editor.getByTitle("Modified lines (click to show)", { exact: true }).click();
|
||||
const modified = page.getByRole("dialog", { name: "Modified lines" });
|
||||
await expect(modified).toBeVisible();
|
||||
const originalText = modified.getByText(original, { exact: false });
|
||||
await expect(originalText).toHaveCSS("font-size", "18px");
|
||||
await expect(modified.getByText(current, { exact: false })).toHaveCount(0);
|
||||
await expect(editor.getByText(current, { exact: true })).toBeVisible();
|
||||
|
||||
const preview = modified.getByRole("region", { name: "Original text" });
|
||||
await expect(preview.locator(".tok-keyword")).toHaveText("const");
|
||||
const toolbar = modified.getByRole("toolbar", { name: "Change actions" });
|
||||
expect(await preview.evaluate((el) => el.scrollWidth > el.clientWidth)).toBe(true);
|
||||
const previewBox = (await preview.boundingBox())!;
|
||||
const toolbarBox = (await toolbar.boundingBox())!;
|
||||
const currentBox = (await editor.getByText(current, { exact: true }).boundingBox())!;
|
||||
expect(previewBox.y).toBeGreaterThanOrEqual(toolbarBox.y + toolbarBox.height - 1);
|
||||
expect(
|
||||
toolbarBox.y >= currentBox.y + currentBox.height - 1 || previewBox.y + previewBox.height <= currentBox.y + 1,
|
||||
).toBe(true);
|
||||
expect(previewBox.x).toBeGreaterThanOrEqual(0);
|
||||
expect(previewBox.x + previewBox.width).toBeLessThanOrEqual(445);
|
||||
await toolbar.getByRole("button", { name: "Next Change" }).click();
|
||||
const added = page.getByRole("dialog", { name: "Added lines" });
|
||||
await expect(added).toBeVisible();
|
||||
await expect(added.getByRole("region", { name: "Original text" })).toHaveCount(0);
|
||||
await expect(added.getByRole("button", { name: "Copy Original Text" })).toBeDisabled();
|
||||
|
||||
await added.getByRole("button", { name: "Next Change" }).click();
|
||||
const deleted = page.getByRole("dialog", { name: "Deleted lines" });
|
||||
await expect(deleted.getByRole("region", { name: "Original text" })).toHaveText("// obsolete window");
|
||||
await deleted.getByRole("button", { name: "Rollback" }).click();
|
||||
await expect(deleted).toBeHidden();
|
||||
await expect(editor.getByText("// obsolete window", { exact: true })).toBeVisible();
|
||||
});
|
||||
@@ -0,0 +1,93 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test.beforeEach(async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Inlay Hints");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
});
|
||||
|
||||
test("inlay hint categories and the preview fit at both settings widths", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const categories = dialog.getByRole("listbox", { name: "Inlay hint categories" });
|
||||
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
|
||||
await expect(preview).toBeVisible();
|
||||
await expect(preview.getByText(": f64", { exact: true })).toBeVisible();
|
||||
|
||||
await page.setViewportSize({ width: 1100, height: 760 });
|
||||
const wideList = (await categories.boundingBox())!;
|
||||
const widePreview = (await preview.boundingBox())!;
|
||||
expect(widePreview.x).toBeGreaterThan(wideList.x + wideList.width);
|
||||
expect(widePreview.y).toBeLessThan(wideList.y + wideList.height);
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
await categories.press("End");
|
||||
await expect(categories.getByRole("option", { name: /^Other hints/ })).toHaveAttribute("aria-selected", "true");
|
||||
await expect(preview.getByText("= 300", { exact: true })).toBeVisible();
|
||||
const narrowList = (await categories.boundingBox())!;
|
||||
const narrowPreview = (await preview.boundingBox())!;
|
||||
expect(narrowPreview.y).toBeGreaterThan(narrowList.y + narrowList.height);
|
||||
await expect(preview).toBeInViewport({ ratio: 0.98 });
|
||||
expect(await preview.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
});
|
||||
|
||||
test("the hint preview follows staged settings and saves the selected category", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const search = dialog.getByRole("textbox", { name: "Search settings" });
|
||||
const categories = dialog.getByRole("listbox", { name: "Inlay hint categories" });
|
||||
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
|
||||
const master = dialog.getByRole("checkbox", { name: "Show inlay hints", exact: true });
|
||||
const parameters = dialog.getByRole("checkbox", { name: "Parameter names", exact: true });
|
||||
const parameterHint = preview.getByText("width:", { exact: true });
|
||||
|
||||
await search.fill("Parameter names");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
await expect(categories.getByRole("option", { name: "Parameter names", exact: true })).toHaveAttribute(
|
||||
"aria-selected",
|
||||
"true",
|
||||
);
|
||||
await expect(parameterHint).toBeVisible();
|
||||
await master.uncheck();
|
||||
await expect(parameters).toBeDisabled();
|
||||
await expect(parameterHint).toHaveCount(0);
|
||||
await expect(dialog.getByRole("checkbox", { name: "Show Code Vision", exact: true })).toBeEnabled();
|
||||
await master.check();
|
||||
await expect(parameterHint).toBeVisible();
|
||||
|
||||
await parameters.uncheck();
|
||||
await expect(parameterHint).toHaveCount(0);
|
||||
await categories.press("Home");
|
||||
await expect(preview.getByText(": f64", { exact: true })).toBeVisible();
|
||||
await dialog.getByRole("button", { name: "Apply", exact: true }).click();
|
||||
await expect(dialog.getByRole("button", { name: "Apply", exact: true })).toBeDisabled();
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
|
||||
await page.keyboard.press("Meta+,");
|
||||
await search.fill("Parameter names");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
await expect(parameters).not.toBeChecked();
|
||||
await expect(parameterHint).toHaveCount(0);
|
||||
});
|
||||
|
||||
test("the hint preview respects the sample language's staged preference", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(() => {
|
||||
window.__ipc.handlers.languages = () => [
|
||||
{ id: "go", name: "Go" },
|
||||
{ id: "rust", name: "Rust" },
|
||||
];
|
||||
});
|
||||
await page.keyboard.press("Meta+,");
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Inlay Hints");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
|
||||
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
|
||||
const typeHint = preview.getByText(": f64", { exact: true });
|
||||
await expect(typeHint).toBeVisible();
|
||||
await dialog.getByRole("checkbox", { name: "Rust", exact: true }).uncheck();
|
||||
await expect(typeHint).toHaveCount(0);
|
||||
await dialog.getByRole("listbox", { name: "Inlay hint categories" }).press("End");
|
||||
await expect(preview.getByText("= 300", { exact: true })).toBeVisible();
|
||||
});
|
||||
@@ -133,3 +133,20 @@ test("rectangular drag remains configurable after removal and saves a middle mou
|
||||
await expect(row).toContainText("Middle Click");
|
||||
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
});
|
||||
|
||||
test("the action search also finds actions by typed shortcut text", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await settings.getByRole("treeitem", { name: "Keymap", exact: true }).click();
|
||||
const search = settings.getByRole("textbox", { name: "Search actions", exact: true });
|
||||
const actions = settings.getByRole("tree", { name: "Actions" });
|
||||
const goToFile = actions.getByRole("treeitem", { name: /Go to File/ });
|
||||
for (const query of ["cmd+shift+o", "Shift+Meta+O", "⇧⌘O"]) {
|
||||
await search.fill(query);
|
||||
await expect(goToFile).toBeVisible();
|
||||
await expect(actions.getByRole("treeitem", { name: /Recent Files/ })).toHaveCount(0);
|
||||
}
|
||||
const shots = process.env.OPENIDEA_E2E_SHOTS;
|
||||
if (shots) await settings.screenshot({ path: `${shots}/after.png`, animations: "disabled" });
|
||||
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
});
|
||||
@@ -0,0 +1,138 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("the floating navigation list stays beside the visible segment and scrolls to keyboard selection", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 600, height: 560 });
|
||||
const folder = "billing";
|
||||
const parent =
|
||||
"/dev/acme-api/quarterly-settlement-and-reconciliation/merchant-accounts-with-exchange-rate-adjustments";
|
||||
const directory = `${parent}/${folder}`;
|
||||
const filename = "SettlementSummary.ts";
|
||||
const path = `${directory}/${filename}`;
|
||||
const long = "QuarterlyReconciliationForPendingSettlementAndCrossBorderMerchantAdjustments.ts";
|
||||
const last = "YearEndTotals.ts";
|
||||
await page.evaluate(async (path) => {
|
||||
const backend = "/src/editor/core/backend.ts";
|
||||
(await import(/* @vite-ignore */ backend)).docBackend().files.set(path, "export const pending = 1;\n");
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile(path);
|
||||
}, path);
|
||||
await expect(page.locator(".cm-content")).toContainText("pending");
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ directory, filename, long, last }) => {
|
||||
window.__ipc.handlers.fs_read_dir = ({ path }) =>
|
||||
path === directory
|
||||
? ["archive", long, ...Array.from({ length: 24 }, (_, i) => `Report-${i + 1}.ts`), filename, last].map(
|
||||
(name) => ({
|
||||
name,
|
||||
path: `${directory}/${name}`,
|
||||
kind: name === "archive" ? "dir" : "file",
|
||||
size: name === "archive" ? 0 : 1,
|
||||
}),
|
||||
)
|
||||
: [];
|
||||
const actions = "/src/platform/actions.ts";
|
||||
await (await import(/* @vite-ignore */ actions)).executeAction("navigate.navigationBar");
|
||||
},
|
||||
{ directory, filename, long, last },
|
||||
);
|
||||
const bar = page.getByRole("toolbar", { name: "Navigation bar" });
|
||||
await expect(bar).toBeVisible();
|
||||
await page.keyboard.press("ArrowLeft");
|
||||
const segment = bar.getByRole("button", { name: folder, exact: true });
|
||||
await expect(segment).toHaveAttribute("aria-current", "location");
|
||||
const barBounds = (await bar.boundingBox())!;
|
||||
await page.keyboard.press("ArrowDown");
|
||||
const list = page.getByRole("listbox", { name: "Children" });
|
||||
await expect(list).toBeVisible();
|
||||
await expect(list.getByRole("option", { name: filename, exact: true })).toHaveAttribute("aria-selected", "true");
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const bounds = (await list.boundingBox())!;
|
||||
return bounds.x >= 5 && bounds.x + bounds.width <= 595;
|
||||
})
|
||||
.toBe(true);
|
||||
expect((await list.boundingBox())!.y).toBeGreaterThanOrEqual(barBounds.y + barBounds.height - 4);
|
||||
expect((await bar.boundingBox())!.height).toBeCloseTo(barBounds.height);
|
||||
|
||||
await page.keyboard.press("Home");
|
||||
const folderRow = list.getByRole("option", { name: "archive" });
|
||||
await expect(folderRow).toHaveAttribute("aria-selected", "true");
|
||||
await expect(folderRow).toBeInViewport({ ratio: 1 });
|
||||
await expect(list.getByRole("option", { name: long, exact: true }).getByTitle(long)).toBeVisible();
|
||||
expect(await list.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await page.keyboard.press("End");
|
||||
const lastRow = list.getByRole("option", { name: last, exact: true });
|
||||
await expect(lastRow).toHaveAttribute("aria-selected", "true");
|
||||
await expect(lastRow).toBeInViewport({ ratio: 1 });
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(list).toBeHidden();
|
||||
await expect(bar).toBeFocused();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(bar).toBeHidden();
|
||||
});
|
||||
|
||||
for (const position of ["top", "statusBar"] as const) {
|
||||
test(`the ${position} navigation list opens toward the editor and keeps folder navigation`, async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const directory = "/dev/acme-api/src";
|
||||
const path = `${directory}/Overview.ts`;
|
||||
await page.evaluate(async (path) => {
|
||||
const backend = "/src/editor/core/backend.ts";
|
||||
(await import(/* @vite-ignore */ backend)).docBackend().files.set(path, "export const overview = 1;\n");
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile(path);
|
||||
}, path);
|
||||
await expect(page.locator(".cm-content")).toContainText("overview");
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ directory, position }) => {
|
||||
const archive = `${directory}/archive`;
|
||||
window.__ipc.handlers.fs_read_dir = ({ path }) =>
|
||||
path === directory
|
||||
? [
|
||||
{ path: archive, name: "archive", kind: "dir", size: 0 },
|
||||
{ path: `${directory}/Overview.ts`, name: "Overview.ts", kind: "file", size: 1 },
|
||||
]
|
||||
: path === archive
|
||||
? [{ path: `${archive}/Previous.ts`, name: "Previous.ts", kind: "file", size: 1 }]
|
||||
: [];
|
||||
const source = await (await fetch("/src/workbench/Workbench.tsx")).text();
|
||||
const project = source.match(/["'](\/src\/platform\/project\.ts(?:\?[^"']+)?)["']/)?.[1];
|
||||
if (!project) throw new Error("Missing project store");
|
||||
const { useProject } = await import(/* @vite-ignore */ project);
|
||||
const settings = useProject.getState().settings;
|
||||
useProject.setState({
|
||||
settings: { ...settings, appearance: { ...settings?.appearance, navigationBar: position } },
|
||||
});
|
||||
},
|
||||
{ directory, position },
|
||||
);
|
||||
const anchor = page
|
||||
.getByRole("navigation", { name: "Breadcrumbs" })
|
||||
.getByRole("button", { name: "src", exact: true });
|
||||
await anchor.click();
|
||||
const list = page.getByRole("listbox", { name: "src", exact: true });
|
||||
const archive = list.getByRole("option", { name: "archive" });
|
||||
await expect(archive).toHaveAttribute("aria-selected", "true");
|
||||
await expect(list).toBeFocused();
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const bounds = (await anchor.boundingBox())!;
|
||||
const popup = (await list.boundingBox())!;
|
||||
return position === "top" ? popup.y >= bounds.y + bounds.height : popup.y + popup.height <= bounds.y;
|
||||
})
|
||||
.toBe(true);
|
||||
await page.keyboard.press("ArrowRight");
|
||||
const nested = page.getByRole("listbox", { name: "archive" });
|
||||
await expect(nested.getByRole("option", { name: "Previous.ts" })).toHaveAttribute("aria-selected", "true");
|
||||
await page.keyboard.press("ArrowLeft");
|
||||
await expect(archive).toHaveAttribute("aria-selected", "true");
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(list).toBeHidden();
|
||||
await expect(anchor).toBeFocused();
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test.beforeEach(async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Notifications");
|
||||
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
|
||||
});
|
||||
|
||||
test("notification group controls stay inside narrow settings", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
const groups = page.getByRole("region", { name: "Groups", exact: true });
|
||||
const popup = groups.getByRole("button", { name: "System Messages popup type" });
|
||||
await expect(popup).toBeInViewport({ ratio: 0.98 });
|
||||
expect(await groups.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
|
||||
const list = groups.getByRole("listbox", { name: "Notification groups" });
|
||||
const controls = groups.getByRole("region", { name: "System Messages", exact: true });
|
||||
const listBounds = (await list.boundingBox())!;
|
||||
expect((await controls.boundingBox())!.y).toBeGreaterThanOrEqual(listBounds.y + listBounds.height);
|
||||
await popup.click();
|
||||
await expect(page.getByRole("option", { name: "Sticky balloon", exact: true })).toBeInViewport();
|
||||
await page.keyboard.press("Escape");
|
||||
|
||||
await list.press("End");
|
||||
const lastGroup = list.getByRole("option", { name: "Distraction Free Mode", exact: true });
|
||||
await expect(lastGroup).toHaveAttribute("aria-selected", "true");
|
||||
await expect(lastGroup).toBeInViewport({ ratio: 0.98 });
|
||||
await list.press("Home");
|
||||
|
||||
await page.setViewportSize({ width: 1100, height: 760 });
|
||||
const wideList = (await list.boundingBox())!;
|
||||
const wideControls = (await controls.boundingBox())!;
|
||||
expect(wideControls.x).toBeGreaterThan(wideList.x + wideList.width);
|
||||
expect(wideControls.y).toBeLessThan(wideList.y + wideList.height);
|
||||
});
|
||||
|
||||
test("notification groups follow settings search and keep edits per group", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const search = dialog.getByRole("textbox", { name: "Search settings" });
|
||||
const list = dialog.getByRole("listbox", { name: "Notification groups" });
|
||||
const systemPopup = dialog.getByRole("button", { name: "System Messages popup type" });
|
||||
const versionControlPopup = dialog.getByRole("button", { name: "Version Control popup type" });
|
||||
const versionControlLog = dialog.getByRole("checkbox", { name: "Show Version Control in tool window" });
|
||||
|
||||
await list.press("ArrowDown");
|
||||
await expect(list.getByRole("option", { name: "Language Servers" })).toHaveAttribute("aria-selected", "true");
|
||||
await search.fill("Version Control");
|
||||
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
|
||||
await expect(list.getByRole("option", { name: "Version Control", exact: true })).toHaveAttribute(
|
||||
"aria-selected",
|
||||
"true",
|
||||
);
|
||||
await versionControlPopup.click();
|
||||
await page.getByRole("option", { name: "No popup", exact: true }).click();
|
||||
await versionControlLog.uncheck();
|
||||
|
||||
await list.press("Home");
|
||||
await expect(systemPopup).toHaveText("Balloon");
|
||||
await expect(dialog.getByRole("checkbox", { name: "Show System Messages in tool window" })).toBeChecked();
|
||||
await list.getByRole("option", { name: "Version Control", exact: true }).click();
|
||||
await expect(versionControlPopup).toHaveText("No popup");
|
||||
await expect(versionControlLog).not.toBeChecked();
|
||||
|
||||
await dialog.getByRole("button", { name: "Apply", exact: true }).click();
|
||||
await expect(dialog.getByRole("button", { name: "Apply", exact: true })).toBeDisabled();
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await page.keyboard.press("Meta+,");
|
||||
await search.fill("Version Control");
|
||||
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
|
||||
await expect(versionControlPopup).toHaveText("No popup");
|
||||
await expect(versionControlLog).not.toBeChecked();
|
||||
});
|
||||
@@ -0,0 +1,56 @@
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
const parent = "/dev/imports/From-vendor/QuarterlySettlementReconciliationAndReportingProjects";
|
||||
const project = `${parent}/settlement-api`;
|
||||
|
||||
test("the trust prompt keeps the folder scope and restricted preview visible in a narrow window", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 420, height: 455 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(() => {
|
||||
const h = window.__ipc.handlers;
|
||||
h.project_trust_status = ({ path }) => ({ root: path, trusted: false, decided: false });
|
||||
h.project_trust_set = () => null;
|
||||
h.open_project = ({ path }) => ({ root: path, name: "settlement-api", trusted: false, isGit: false, settings: {} });
|
||||
h.fs_read_dir = () => [];
|
||||
});
|
||||
const open = () =>
|
||||
page.evaluate(async (path) => {
|
||||
const projectModule = "/src/platform/project.ts";
|
||||
const { openProject } = await import(/* @vite-ignore */ projectModule);
|
||||
void openProject(path).catch(() => undefined);
|
||||
}, project);
|
||||
await open();
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Trust and Open Project?" });
|
||||
const restricted = dialog.getByRole("button", { name: "Preview in Restricted Mode" });
|
||||
const folder = dialog.getByRole("checkbox", { name: /Trust projects in/ });
|
||||
const projectAction = dialog.getByRole("button", { name: "Trust Project", exact: true });
|
||||
const folderAction = dialog.getByRole("button", { name: "Trust Folder", exact: true });
|
||||
await expect(restricted).toBeFocused();
|
||||
await expect(projectAction).toBeVisible();
|
||||
await expect(folder).not.toBeChecked();
|
||||
await expect(dialog.getByTitle(project, { exact: true })).toBeVisible();
|
||||
await expect(dialog.getByTitle(parent, { exact: true })).toBeVisible();
|
||||
await folder.check();
|
||||
await expect(folderAction).toHaveCount(1);
|
||||
await expect(projectAction).toHaveCount(0);
|
||||
for (const selector of ["[data-dialog-body]", "[data-dialog-footer]"]) {
|
||||
expect(await dialog.locator(selector).evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
}
|
||||
await expect(restricted).toBeInViewport({ ratio: 1 });
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(dialog).toBeHidden();
|
||||
expect(await ipcCalls(page, "project_trust_set")).toEqual([]);
|
||||
expect(await ipcCalls(page, "open_project")).toEqual([]);
|
||||
|
||||
await open();
|
||||
await expect(projectAction).toBeVisible();
|
||||
await expect(folder).not.toBeChecked();
|
||||
await folder.check();
|
||||
await restricted.click();
|
||||
await expect(dialog).toBeHidden();
|
||||
expect(await ipcCalls(page, "project_trust_set")).toEqual([{ path: project, trusted: false, folder: false }]);
|
||||
await expect.poll(() => ipcCalls(page, "open_project")).toEqual([{ path: project }]);
|
||||
});
|
||||
@@ -0,0 +1,88 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Quick Evaluate opens an object tree that fits the editor and returns focus on Escape", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 445, height: 500 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(async () => {
|
||||
const path = "/dev/acme-api/settlement.py";
|
||||
const h = window.__ipc.handlers;
|
||||
const value = (name: string, text: string, typeName: string, variablesReference = 0) => ({
|
||||
name,
|
||||
value: text,
|
||||
typeName,
|
||||
variablesReference,
|
||||
evaluateName: name,
|
||||
});
|
||||
h.fs_probe = () => ({ size: 48, binary: false, tooLarge: false });
|
||||
h.fs_read_text = () => "summary = {}\nsubtotal = 42\n";
|
||||
h.debug_evaluate_in = ({ expression }) =>
|
||||
expression === "summary" ? value("summary", "{...}", "dict", 101) : value("subtotal", "42", "int");
|
||||
h.debug_variables = ({ reference }) =>
|
||||
reference === 101
|
||||
? [value("audit", "{...}", "dict", 102), value("total", "47.74", "float")]
|
||||
: Array.from({ length: 22 }, (_, i) => value(`entry${i.toString().padStart(2, "0")}`, String(i), "int"));
|
||||
h.debug_scopes = () => [];
|
||||
const servicesModule = "/src/workbench/contributions.ts";
|
||||
const { editorService } = await import(/* @vite-ignore */ servicesModule);
|
||||
await editorService().openFile(path, { focus: true });
|
||||
const debugModule = "/src/features/debugger/state.ts";
|
||||
const { adoptSession, publishContext } = await import(/* @vite-ignore */ debugModule);
|
||||
adoptSession(91, {
|
||||
name: "Checkout",
|
||||
adapter: "debugpy",
|
||||
status: "paused",
|
||||
selectedFrame: 11,
|
||||
frames: [{ id: 11, name: "checkout", path, line: 0, column: 0, presentationHint: null }],
|
||||
});
|
||||
publishContext();
|
||||
});
|
||||
const editor = page.locator(".cm-editor");
|
||||
const content = editor.locator(".cm-content");
|
||||
await expect(content).toBeVisible();
|
||||
await content.evaluate((el) => {
|
||||
const { view } = (el as HTMLElement & { cmTile: { view: EditorView } }).cmTile;
|
||||
view.dispatch({ changes: { from: 0, to: view.state.doc.length, insert: "summary = {}\nsubtotal = 42\n" } });
|
||||
});
|
||||
const evaluate = (line: number) =>
|
||||
content.evaluate(async (el, lineNo) => {
|
||||
const { view } = (el as HTMLElement & { cmTile: { view: EditorView } }).cmTile;
|
||||
view.dispatch({ selection: { anchor: view.state.doc.line(lineNo).from + 2 } });
|
||||
const actionModule = "/src/platform/actions.ts";
|
||||
await (await import(/* @vite-ignore */ actionModule)).executeAction("debug.quickEvaluate");
|
||||
}, line);
|
||||
|
||||
await evaluate(1);
|
||||
const hint = page.locator(".cm-lsp-hint");
|
||||
await expect(hint).toBeVisible();
|
||||
await expect(hint.getByRole("button", { name: "Expand value" })).toHaveCount(0);
|
||||
const tree = hint.getByRole("tree", { name: "summary" });
|
||||
await expect(tree).toBeFocused();
|
||||
await expect(tree.getByText("audit", { exact: true })).toBeVisible();
|
||||
await page.setViewportSize({ width: 400, height: 360 });
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const editorBox = (await editor.boundingBox())!;
|
||||
const hintBox = (await hint.boundingBox())!;
|
||||
return hintBox.x >= editorBox.x - 1 && hintBox.x + hintBox.width <= editorBox.x + editorBox.width + 1;
|
||||
})
|
||||
.toBe(true);
|
||||
|
||||
await tree.getByText("audit", { exact: true }).click();
|
||||
await tree.press("ArrowRight");
|
||||
await expect(tree.getByText("entry00", { exact: true })).toBeVisible();
|
||||
expect(await tree.evaluate((el) => el.scrollHeight > el.clientHeight)).toBe(true);
|
||||
await tree.press("Escape");
|
||||
await expect(hint).toBeHidden();
|
||||
await expect(content).toBeFocused();
|
||||
|
||||
await evaluate(2);
|
||||
await expect(hint.getByRole("tree")).toHaveCount(0);
|
||||
await expect(hint).toHaveText(/subtotal\s*=\s*42/);
|
||||
expect(await ipcCalls(page, "debug_evaluate_in")).toEqual([
|
||||
{ session: 91, frameId: 11, expression: "summary", context: "hover" },
|
||||
{ session: 91, frameId: 11, expression: "subtotal", context: "hover" },
|
||||
]);
|
||||
});
|
||||
@@ -0,0 +1,74 @@
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Rollback fits a short window and scopes its options to checked files", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 410, height: 330 });
|
||||
await stubDesktop(page);
|
||||
const root = "/dev/settlement-engine";
|
||||
const added = `${root}/ledger/additional-settlement-schedule.txt`;
|
||||
const deleted = `${root}/ledger/retired-settlement-routing.txt`;
|
||||
const modified = Array.from({ length: 16 }, (_, i) => `${root}/ledger/merchant-settlement-batch-${i + 1}.txt`);
|
||||
|
||||
await page.evaluate(
|
||||
async ({ root, added, deleted, modified }) => {
|
||||
const status = [
|
||||
{ path: added, staged: "added", unstaged: null },
|
||||
{ path: deleted, staged: "deleted", unstaged: null },
|
||||
...modified.map((path) => ({ path, staged: null, unstaged: "modified" })),
|
||||
].map((file) => ({ ...file, relPath: file.path.slice(root.length + 1), renamedFrom: null }));
|
||||
const branch = { head: "main", headCommit: "c1", upstream: null, ahead: 0, behind: 0, operation: null };
|
||||
const h = window.__ipc.handlers;
|
||||
h.vcs_branch_info = () => branch;
|
||||
h.vcs_roots = () => [{ root, ...branch }];
|
||||
h.vcs_status = () => status;
|
||||
h.vcs_unstage = () => null;
|
||||
h.vcs_discard = () => null;
|
||||
|
||||
const storeModule = "/src/features/vcs/store.ts";
|
||||
const { useVcs } = await import(/* @vite-ignore */ storeModule);
|
||||
useVcs.setState({ available: true, root, repo: root, roots: [root], branch, status });
|
||||
const contextModule = "/src/platform/context.ts";
|
||||
const { setContext } = await import(/* @vite-ignore */ contextModule);
|
||||
setContext("vcsAvailable", true);
|
||||
const actionsModule = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ actionsModule);
|
||||
await executeAction("vcs.rollback", [root]);
|
||||
},
|
||||
{ root, added, deleted, modified },
|
||||
);
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Rollback Changes", exact: true });
|
||||
const tree = dialog.getByRole("tree", { name: "Files to roll back" });
|
||||
const body = dialog.locator("[data-dialog-body]");
|
||||
await expect(tree).toBeVisible();
|
||||
expect(await body.evaluate((el) => el.scrollHeight - el.clientHeight)).toBeLessThanOrEqual(1);
|
||||
expect(await body.evaluate((el) => el.scrollWidth - el.clientWidth)).toBe(0);
|
||||
expect(await tree.evaluate((el) => el.scrollHeight > el.clientHeight)).toBe(true);
|
||||
await expect(tree).toBeFocused();
|
||||
await expect(tree.getByTitle("ledger/additional-settlement-schedule.txt", { exact: true })).toBeVisible();
|
||||
|
||||
const status = dialog.getByRole("status");
|
||||
const deleteCopies = dialog.getByRole("checkbox", { name: "Delete local copies of added files" });
|
||||
const rollback = dialog.getByRole("button", { name: "Rollback", exact: true });
|
||||
await expect(status).toHaveText("1 added16 modified1 deleted");
|
||||
await expect(deleteCopies).toBeEnabled();
|
||||
await expect(deleteCopies).not.toBeChecked();
|
||||
await deleteCopies.check();
|
||||
await tree.getByRole("checkbox", { name: "Include additional-settlement-schedule.txt" }).uncheck();
|
||||
await expect(deleteCopies).toBeDisabled();
|
||||
await expect(status).toHaveText("16 modified1 deleted");
|
||||
|
||||
const rootCheckbox = tree.getByRole("checkbox", { name: "Include settlement-engine", exact: true });
|
||||
await expect(rootCheckbox).toHaveAttribute("aria-checked", "mixed");
|
||||
await rootCheckbox.click();
|
||||
await rootCheckbox.uncheck();
|
||||
await expect(rollback).toBeDisabled();
|
||||
await expect(status).toHaveText("No files selected");
|
||||
|
||||
await tree.getByRole("checkbox", { name: "Include merchant-settlement-batch-1.txt", exact: true }).check();
|
||||
await expect(status).toHaveText("1 modified");
|
||||
await expect(deleteCopies).toBeDisabled();
|
||||
await rollback.click();
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect.poll(() => ipcCalls(page, "vcs_discard")).toEqual([{ paths: [modified[0]] }]);
|
||||
expect(await ipcCalls(page, "vcs_unstage")).toEqual([]);
|
||||
});
|
||||
@@ -0,0 +1,103 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, ipcCalls, openFromTree, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Safe Delete lays out the search option and makes View Usages the default in a narrow window", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const editor = await openFromTree(page, "App.tsx");
|
||||
await page.setViewportSize({ width: 425, height: 500 });
|
||||
const content = editor.locator(".cm-content");
|
||||
const symbol = "reconcileOutstandingSupplierAdjustmentsForTheMonthlySettlementArchive";
|
||||
const source = [
|
||||
`export function ${symbol}() {`,
|
||||
" return 1;",
|
||||
"}",
|
||||
"",
|
||||
`const debit = ${symbol}();`,
|
||||
`const credit = ${symbol}();`,
|
||||
].join("\n");
|
||||
await content.evaluate(
|
||||
(element, { source, symbol }) => {
|
||||
const view = (element as HTMLElement & { cmTile: { view: EditorView } }).cmTile.view;
|
||||
view.dispatch({
|
||||
changes: { from: 0, to: view.state.doc.length, insert: source },
|
||||
selection: { anchor: source.indexOf(symbol) + 1 },
|
||||
});
|
||||
view.focus();
|
||||
},
|
||||
{ source, symbol },
|
||||
);
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
({ source, symbol }) => {
|
||||
const path = "/dev/acme-api/App.tsx";
|
||||
const range = (line: number, col: number, end = col + symbol.length) => ({
|
||||
start: { line, col },
|
||||
end: { line, col: end },
|
||||
});
|
||||
const selection = range(0, "export function ".length);
|
||||
const handlers = window.__ipc.handlers;
|
||||
handlers.lsp_goto = () => [{ path, range: selection }];
|
||||
handlers.doc_outline = () => [
|
||||
{
|
||||
name: symbol,
|
||||
detail: null,
|
||||
kind: "function",
|
||||
range: { start: { line: 0, col: 0 }, end: { line: 2, col: 1 } },
|
||||
selection_range: selection,
|
||||
children: [],
|
||||
},
|
||||
];
|
||||
handlers.languages = () => [];
|
||||
handlers.lsp_references = () => ({
|
||||
locations: [
|
||||
{ path, range: range(4, "const debit = ".length) },
|
||||
{ path, range: range(5, "const credit = ".length) },
|
||||
],
|
||||
incomplete: null,
|
||||
});
|
||||
handlers.fs_read_text = () => source;
|
||||
},
|
||||
{ source, symbol },
|
||||
);
|
||||
const openSafeDelete = () =>
|
||||
page.evaluate(async () => {
|
||||
const module = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ module);
|
||||
void executeAction("refactor.safeDelete");
|
||||
});
|
||||
const usageSearches = async () => (await ipcCalls(page, "lsp_references")).filter((call) => call.projectWide);
|
||||
|
||||
await openSafeDelete();
|
||||
const prompt = page.getByRole("dialog", { name: "Safe Delete", exact: true });
|
||||
await expect(prompt.locator("[data-dialog-titlebar]")).toHaveText("Safe Delete");
|
||||
const description = prompt.getByText(`Delete Function '${symbol}'?`);
|
||||
const commentSearch = prompt.getByRole("checkbox", { name: "Search in comments and strings" });
|
||||
await expect(commentSearch).toBeChecked();
|
||||
const expectedLeft = (await description.boundingBox())!.x;
|
||||
expect((await commentSearch.boundingBox())!.x).toBeCloseTo(expectedLeft, 0);
|
||||
await expect(prompt.locator("[data-dialog-body]")).toContainText(symbol);
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(prompt).toBeHidden();
|
||||
await expect(content).toBeFocused();
|
||||
expect(await usageSearches()).toHaveLength(0);
|
||||
|
||||
await openSafeDelete();
|
||||
await commentSearch.uncheck();
|
||||
await prompt.getByRole("button", { name: "OK", exact: true }).click();
|
||||
const conflict = page.getByRole("dialog", { name: "Usages Detected", exact: true });
|
||||
await expect(conflict.getByRole("heading", { name: "2 usages found" })).toBeVisible();
|
||||
await expect(conflict.getByText(`Function '${symbol}' has 2 usages that are not safe to delete.`)).toBeVisible();
|
||||
for (const button of ["View Usages", "Delete Anyway", "Cancel"]) {
|
||||
await expect(conflict.getByRole("button", { name: button, exact: true })).toBeInViewport({ ratio: 1 });
|
||||
}
|
||||
expect(
|
||||
await conflict.locator("[data-dialog-body]").evaluate((element) => element.scrollWidth - element.clientWidth),
|
||||
).toBe(0);
|
||||
await expect(conflict.getByRole("button", { name: "View Usages" })).toBeFocused();
|
||||
await page.keyboard.press("Enter");
|
||||
await expect(conflict).toBeHidden();
|
||||
await expect(page.getByRole("region", { name: "Find Usages", exact: true })).toBeVisible();
|
||||
await expect(content).toContainText("export function");
|
||||
expect(await usageSearches()).toHaveLength(1);
|
||||
});
|
||||
@@ -0,0 +1,86 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("the scratch language chooser fits short windows and keeps recents separate from search results", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 470, height: 400 });
|
||||
const long = "Zebra Configuration Language for Regional Settlement and Reconciliation Pipelines";
|
||||
await page.evaluate(async (long) => {
|
||||
const scratch = "/src/features/scratch/scratches.ts";
|
||||
const store = "/src/features/scratch/store.ts";
|
||||
const actions = "/src/platform/actions.ts";
|
||||
const { setScratchBackend } = await import(/* @vite-ignore */ scratch);
|
||||
const { rememberLanguage } = await import(/* @vite-ignore */ store);
|
||||
setScratchBackend({
|
||||
dataDir: async () => "/test-app-data",
|
||||
listNames: async () => [],
|
||||
createDir: async () => {},
|
||||
createFile: async () => {},
|
||||
languages: async () => [
|
||||
...Array.from({ length: 24 }, (_, i) => {
|
||||
const n = String(i + 1).padStart(2, "0");
|
||||
return { id: `config-${n}`, name: `Configuration ${n}`, ext: `cfg${n}` };
|
||||
}),
|
||||
{ id: "json", name: "JSON", ext: "json" },
|
||||
{ id: "python", name: "Python", ext: "py" },
|
||||
{ id: "zebra", name: long, ext: "zebra" },
|
||||
],
|
||||
open: async (path: string) => localStorage.setItem("scratch-layout-opened", path),
|
||||
});
|
||||
rememberLanguage("json");
|
||||
rememberLanguage("python");
|
||||
await (await import(/* @vite-ignore */ actions)).executeAction("file.newScratchFile");
|
||||
}, long);
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "New Scratch File", exact: true });
|
||||
const input = dialog.getByRole("textbox", { name: "Filter languages" });
|
||||
await expect(input).toBeFocused();
|
||||
const list = dialog.getByRole("listbox", { name: "Languages" });
|
||||
for (let i = 0; i < 3; i++) await input.press("PageDown");
|
||||
const last = list.getByRole("option", { name: long, exact: true });
|
||||
await expect(last).toHaveAttribute("aria-selected", "true");
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const popup = (await dialog.boundingBox())!;
|
||||
const item = (await last.boundingBox())!;
|
||||
return item.y + item.height - popup.y - popup.height;
|
||||
})
|
||||
.toBeLessThanOrEqual(1);
|
||||
await expect(last).toBeInViewport({ ratio: 0.99 });
|
||||
await expect(last.getByTitle(long)).toBeVisible();
|
||||
await expect(input).toBeInViewport({ ratio: 1 });
|
||||
|
||||
await input.fill("python");
|
||||
const python = list.getByRole("option", { name: "Python", exact: true });
|
||||
await expect(python).toHaveAttribute("aria-selected", "true");
|
||||
await expect(list.getByRole("separator")).toHaveCount(0);
|
||||
await input.fill("");
|
||||
const divider = list.getByRole("separator");
|
||||
await expect(divider).toBeVisible();
|
||||
await expect(python).toHaveAttribute("aria-selected", "true");
|
||||
await input.press("ArrowDown");
|
||||
const json = list.getByRole("option", { name: "JSON", exact: true });
|
||||
await expect(json).toHaveAttribute("aria-selected", "true");
|
||||
await input.press("ArrowDown");
|
||||
const first = list.getByRole("option", { name: "Configuration 01", exact: true });
|
||||
await expect(first).toHaveAttribute("aria-selected", "true");
|
||||
expect((await divider.boundingBox())!.y).toBeLessThan((await first.boundingBox())!.y);
|
||||
expect(await input.getAttribute("aria-activedescendant")).toBe(await first.getAttribute("id"));
|
||||
await page.setViewportSize({ width: 640, height: 520 });
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const bounds = (await dialog.boundingBox())!;
|
||||
return Math.abs(bounds.x + bounds.width / 2 - 320);
|
||||
})
|
||||
.toBeLessThanOrEqual(1);
|
||||
await expect(input).toBeFocused();
|
||||
|
||||
await input.fill("zzz");
|
||||
await expect(dialog.getByText("No matching languages")).toBeVisible();
|
||||
await input.fill("json");
|
||||
await input.press("Enter");
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect
|
||||
.poll(() => page.evaluate(() => localStorage.getItem("scratch-layout-opened")))
|
||||
.toBe("/test-app-data/scratches/scratch.json");
|
||||
});
|
||||
@@ -0,0 +1,94 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("selection history keeps a full-width diff above a keyboard-resizable revision table", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 1140, height: 740 });
|
||||
const filename = "QuarterlyCrossBorderSettlementReconciliationProjection.ts";
|
||||
const path = `/dev/acme-api/modules/${filename}`;
|
||||
const lastMessage = "Introduce the reconciliation projection for pending cross-border merchant settlements";
|
||||
await page.evaluate(async (path) => {
|
||||
const backend = "/src/editor/core/backend.ts";
|
||||
(await import(/* @vite-ignore */ backend))
|
||||
.docBackend()
|
||||
.files.set(path, "export const pending = 0;\nconst projection = uncommitted;\n");
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile(path);
|
||||
}, path);
|
||||
const editor = page.locator(".cm-content");
|
||||
await expect(editor).toContainText("uncommitted");
|
||||
await editor.evaluate((el) => {
|
||||
const view = (el as HTMLElement & { cmTile: { view: EditorView } }).cmTile.view;
|
||||
const line = view.state.doc.line(2);
|
||||
view.dispatch({ selection: { anchor: line.from, head: line.to } });
|
||||
view.focus();
|
||||
});
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ path, lastMessage }) => {
|
||||
window.__ipc.handlers.cancel_request = () => null;
|
||||
window.__ipc.handlers.vcs_block_history = () => ({
|
||||
headLines: [1, 1],
|
||||
revisions: Array.from({ length: 22 }, (_, i) => ({
|
||||
id: (i + 16).toString(16).padStart(40, "0"),
|
||||
shortId: (i + 16).toString(16).padStart(7, "0"),
|
||||
author: "Alexandra Reconciliation Coordinator",
|
||||
email: "[email protected]",
|
||||
timeMs: 1738329600000 - i * 86400000,
|
||||
summary: i === 21 ? lastMessage : `Update reconciliation estimate ${22 - i}`,
|
||||
path,
|
||||
before: `const projection = estimate${21 - i};\n`,
|
||||
after: `const projection = estimate${22 - i};\n`,
|
||||
beforeLine: 1,
|
||||
afterLine: 1,
|
||||
})),
|
||||
});
|
||||
const actions = "/src/platform/actions.ts";
|
||||
await (await import(/* @vite-ignore */ actions)).executeAction("vcs.showHistoryForSelection");
|
||||
},
|
||||
{ path, lastMessage },
|
||||
);
|
||||
|
||||
const diff = page.locator(".cm-mergeView");
|
||||
await expect(diff).toContainText("uncommitted");
|
||||
const revisions = page.getByRole("grid", { name: "Revisions" });
|
||||
const history = revisions.or(page.getByRole("listbox", { name: "Revisions" }));
|
||||
await expect(history).toBeVisible();
|
||||
const preview = (await diff.boundingBox())!;
|
||||
const list = (await history.boundingBox())!;
|
||||
expect(list.y).toBeGreaterThanOrEqual(preview.y + preview.height - 1);
|
||||
expect(preview.width).toBeGreaterThanOrEqual(list.width - 2);
|
||||
|
||||
await expect(revisions.getByRole("columnheader")).toHaveText(["Revision", "Date", "Author", "Message"]);
|
||||
const divider = page.getByRole("separator", { name: "Revisions", exact: true });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
const initial = (await divider.boundingBox())!.y;
|
||||
await divider.press("ArrowUp");
|
||||
await expect.poll(async () => (await divider.boundingBox())!.y).toBeLessThan(initial);
|
||||
await expect(revisions.getByRole("row", { selected: true })).toContainText("Local Changes");
|
||||
|
||||
await page.setViewportSize({ width: 490, height: 620 });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
await expect(page.getByTitle(`${filename}:2-2`, { exact: true })).toBeVisible();
|
||||
const body = revisions.getByRole("rowgroup");
|
||||
await body.press("End");
|
||||
const last = revisions.getByRole("row", { selected: true });
|
||||
await expect(last.getByRole("gridcell", { name: lastMessage, exact: true })).toHaveAttribute("title", lastMessage);
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const listBounds = (await body.boundingBox())!;
|
||||
const rowBounds = (await last.boundingBox())!;
|
||||
return Math.max(listBounds.y - rowBounds.y, rowBounds.y + rowBounds.height - listBounds.y - listBounds.height);
|
||||
})
|
||||
.toBeLessThanOrEqual(1);
|
||||
const headers = revisions.getByRole("columnheader");
|
||||
const cells = last.getByRole("gridcell");
|
||||
for (let i = 0; i < 4; i++) {
|
||||
expect(
|
||||
Math.abs((await headers.nth(i).boundingBox())!.x - (await cells.nth(i).boundingBox())!.x),
|
||||
).toBeLessThanOrEqual(1);
|
||||
}
|
||||
expect(await body.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await expect(diff).toContainText("estimate1");
|
||||
});
|
||||
@@ -2,9 +2,9 @@ import { expect, test } from "./fixtures";
|
||||
|
||||
for (const [id, selector] of [
|
||||
["build.deployment", "[class*='layout'] > [class*='note']"],
|
||||
["editor.inspections", "[class*='split'] > [class*='details']"],
|
||||
["editor.inspections", "[class*='split'] section[class*='details']"],
|
||||
["languages.servers", "[class*='body'] > [class*='language'][aria-label]"],
|
||||
["plugins", "[class*='body'] > [class*='details']"],
|
||||
["plugins", "[class*='body'] [class*='details'][aria-label]"],
|
||||
["agents.list", "section[aria-label='Codex']"],
|
||||
] as const) {
|
||||
test(`${id} keeps its details usable beside the list`, async ({ workbench: page }) => {
|
||||
@@ -69,20 +69,53 @@ test("every color scheme page keeps its attribute tree visible", async ({ workbe
|
||||
}
|
||||
});
|
||||
|
||||
for (const id of ["editor.fileTemplates", "editor.liveTemplates"]) {
|
||||
test(`${id} keeps its editor reachable beside the template list`, async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
await expect(page.getByRole("dialog", { name: "Settings", exact: true })).toBeVisible();
|
||||
await page.evaluate(async (id) => {
|
||||
const path = "/src/features/settings/model/staging.ts";
|
||||
(await import(/* @vite-ignore */ path)).selectPage(id);
|
||||
}, id);
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
const editor = page.locator("[class*='split'] > [class*='editor']").first();
|
||||
await expect(editor).toBeAttached();
|
||||
expect((await editor.boundingBox())!.width).toBeGreaterThan(200);
|
||||
test("Live Templates gives the editor the full settings pane width and keeps variable fields reachable", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await expect(dialog).toBeVisible();
|
||||
await page.evaluate(async () => {
|
||||
const path = "/src/features/settings/model/staging.ts";
|
||||
(await import(/* @vite-ignore */ path)).selectPage("editor.liveTemplates");
|
||||
});
|
||||
}
|
||||
const list = dialog.getByRole("listbox", { name: "Live templates" });
|
||||
const body = dialog.getByRole("textbox", { name: "Template text" });
|
||||
await dialog.getByRole("button", { name: "Add Template" }).click();
|
||||
await expect(body).toBeVisible();
|
||||
const listBounds = (await list.boundingBox())!;
|
||||
const bodyBounds = (await body.boundingBox())!;
|
||||
expect(bodyBounds.y).toBeGreaterThan(listBounds.y + listBounds.height);
|
||||
expect(bodyBounds.width).toBeGreaterThan(listBounds.width - 32);
|
||||
|
||||
const handle = dialog.getByRole("separator", { name: "Resize template panes" });
|
||||
await expect(handle).toHaveAttribute("aria-orientation", "horizontal");
|
||||
await handle.press("ArrowDown");
|
||||
await expect.poll(async () => (await list.boundingBox())!.height).toBeGreaterThan(listBounds.height + 10);
|
||||
|
||||
await dialog.getByRole("textbox", { name: "Abbreviation" }).fill("settlement");
|
||||
await dialog.getByRole("textbox", { name: "Filter templates" }).fill("settlement");
|
||||
await expect(list.getByRole("option")).toHaveCount(1);
|
||||
await expect(list.getByRole("option")).toHaveAttribute("aria-selected", "true");
|
||||
await body.fill("record($SETTLEMENT_REFERENCE_IDENTIFIER$, $AMOUNT$)$END$");
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 600 });
|
||||
await body.scrollIntoViewIfNeeded();
|
||||
await expect(body).toBeInViewport({ ratio: 0.98 });
|
||||
const narrowList = (await list.boundingBox())!;
|
||||
const narrowBody = (await body.boundingBox())!;
|
||||
expect(narrowBody.x + narrowBody.width).toBeLessThanOrEqual(narrowList.x + narrowList.width);
|
||||
const variables = dialog.getByRole("table");
|
||||
const expression = variables.getByRole("textbox", { name: "SETTLEMENT_REFERENCE_IDENTIFIER expression" });
|
||||
await expression.scrollIntoViewIfNeeded();
|
||||
await expect(expression).toBeInViewport({ ratio: 1 });
|
||||
await expression.fill("fileName()");
|
||||
await expect(expression).toHaveValue("fileName()");
|
||||
await expect(
|
||||
variables.getByRole("checkbox", { name: "Skip SETTLEMENT_REFERENCE_IDENTIFIER if defined" }),
|
||||
).toBeVisible();
|
||||
expect(await variables.evaluate((element) => element.scrollWidth - element.clientWidth)).toBe(0);
|
||||
});
|
||||
|
||||
test("Project Structure keeps every details pane usable in a compact window", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+;");
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, openFromTree, test } from "./fixtures";
|
||||
|
||||
test("Surround With keeps its title and keyboard-selected actions visible in a short window", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 680, height: 320 });
|
||||
const editor = await openFromTree(page, "App.tsx");
|
||||
const content = editor.locator(".cm-content");
|
||||
const source = [
|
||||
"const fee = 5;",
|
||||
"",
|
||||
"function settle(amount: number) {",
|
||||
" const adjusted = amount - fee;",
|
||||
" const receipt = adjusted.toString();",
|
||||
" console.log(receipt);",
|
||||
" return adjusted;",
|
||||
"}",
|
||||
].join("\n");
|
||||
const selectedText = " console.log(receipt);";
|
||||
await content.evaluate(
|
||||
(node, { source, selectedText }) => {
|
||||
const view = (node as HTMLElement & { cmTile: { view: EditorView } }).cmTile.view;
|
||||
const start = source.indexOf(selectedText);
|
||||
view.dispatch({
|
||||
changes: { from: 0, to: view.state.doc.length, insert: source },
|
||||
selection: { anchor: start, head: start + selectedText.length },
|
||||
scrollIntoView: true,
|
||||
});
|
||||
view.focus();
|
||||
},
|
||||
{ source, selectedText },
|
||||
);
|
||||
const openSurround = () =>
|
||||
page.evaluate(async () => {
|
||||
const module = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ module);
|
||||
await executeAction("code.surroundWith");
|
||||
});
|
||||
|
||||
await openSurround();
|
||||
const popup = page.getByRole("dialog", { name: "Surround With", exact: true });
|
||||
const title = popup.getByText("Surround With", { exact: true });
|
||||
const list = popup.getByRole("listbox");
|
||||
await expect(title).toBeInViewport({ ratio: 1 });
|
||||
await expect.poll(() => list.evaluate((node) => node.scrollHeight - node.clientHeight)).toBeGreaterThan(0);
|
||||
await expect.poll(() => popup.evaluate((node) => node.scrollHeight - node.clientHeight)).toBe(0);
|
||||
|
||||
const first = list.getByRole("option", { name: /^1\.?\s+if$/ });
|
||||
await expect(first).toHaveAttribute("aria-selected", "true");
|
||||
const action = first.getByText("if", { exact: true });
|
||||
const mnemonic = first.getByText(/^1\.?$/, { exact: true });
|
||||
expect((await mnemonic.boundingBox())!.x + (await mnemonic.boundingBox())!.width).toBeLessThan(
|
||||
(await action.boundingBox())!.x,
|
||||
);
|
||||
expect(await action.evaluate((node) => getComputedStyle(node).fontSize)).toBe("13px");
|
||||
await page.keyboard.press("End");
|
||||
const last = list.getByRole("option", { name: /!\(expr\)/ });
|
||||
await expect(last).toHaveAttribute("aria-selected", "true");
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(title).toBeInViewport({ ratio: 1 });
|
||||
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(popup).toBeHidden();
|
||||
await expect(content).toBeFocused();
|
||||
await expect(content).toContainText("console.log(receipt);");
|
||||
|
||||
await openSurround();
|
||||
await expect(first).toBeVisible();
|
||||
await page.keyboard.press("1");
|
||||
await expect(popup).toBeHidden();
|
||||
await expect(content).toContainText(/if \([^)]*\) \{/);
|
||||
await expect(content).toContainText("console.log(receipt);");
|
||||
});
|
||||
@@ -17,7 +17,7 @@ func main() {
|
||||
[[language-servers]]
|
||||
name = "gopls"
|
||||
command = "gopls"
|
||||
initialization-options = { semanticTokens = true, vulncheck = "Imports" }
|
||||
initialization-options = { semanticTokens = true, vulncheck = "Imports", hints = { constantValues = true } }
|
||||
root-markers = ["go.work", "go.mod"]
|
||||
install-hint = "go install golang.org/x/tools/gopls@latest"
|
||||
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
diff --git a/dist/index.cjs b/dist/index.cjs
|
||||
index 4172cb0f2befc00da9ae09eb3486cae743403a97..ed3c542377fc6dff0195dd9116c16464fb615919 100644
|
||||
--- a/dist/index.cjs
|
||||
+++ b/dist/index.cjs
|
||||
@@ -208,7 +208,9 @@ class Stack {
|
||||
if (index > 0 && (this.buffer[index - 4] != 0 /* Term.Err */ || this.buffer[index - 1] < 0)) {
|
||||
let mustMove = false;
|
||||
for (let scan = index; scan > 0 && this.buffer[scan - 2] > end; scan -= 4) {
|
||||
- if (this.buffer[scan - 1] >= 0) {
|
||||
+ // Reused skipped nodes after the end must be moved out too.
|
||||
+ if (this.buffer[scan - 1] >= 0 ||
|
||||
+ this.buffer[scan - 1] == -1 && this.p.reused[this.buffer[scan - 4]].type.isSkipped) {
|
||||
mustMove = true;
|
||||
break;
|
||||
}
|
||||
@@ -278,7 +280,11 @@ class Stack {
|
||||
this.p.reused.push(value);
|
||||
index++;
|
||||
}
|
||||
- let end = this.reducePos = this.pos = start + value.length;
|
||||
+ // A reused skipped node (a comment) is not part of the node being
|
||||
+ // reduced: like a shifted skipped token, it leaves reducePos alone.
|
||||
+ let end = this.pos = start + value.length;
|
||||
+ if (!value.type.isSkipped)
|
||||
+ this.reducePos = end;
|
||||
this.pushState(next, start);
|
||||
this.buffer.push(index, start, end, -1 /* size == -1 means this is a reused value */);
|
||||
if (this.curContext)
|
||||
diff --git a/dist/index.js b/dist/index.js
|
||||
index 8fd3f87829c312b93ce022867fd17bf34da0dbc0..f67b16d2f46d683f12ddc81534efbf50925e7c65 100644
|
||||
--- a/dist/index.js
|
||||
+++ b/dist/index.js
|
||||
@@ -206,7 +206,9 @@ class Stack {
|
||||
if (index > 0 && (this.buffer[index - 4] != 0 /* Term.Err */ || this.buffer[index - 1] < 0)) {
|
||||
let mustMove = false;
|
||||
for (let scan = index; scan > 0 && this.buffer[scan - 2] > end; scan -= 4) {
|
||||
- if (this.buffer[scan - 1] >= 0) {
|
||||
+ // Reused skipped nodes after the end must be moved out too.
|
||||
+ if (this.buffer[scan - 1] >= 0 ||
|
||||
+ this.buffer[scan - 1] == -1 && this.p.reused[this.buffer[scan - 4]].type.isSkipped) {
|
||||
mustMove = true;
|
||||
break;
|
||||
}
|
||||
@@ -276,7 +278,11 @@ class Stack {
|
||||
this.p.reused.push(value);
|
||||
index++;
|
||||
}
|
||||
- let end = this.reducePos = this.pos = start + value.length;
|
||||
+ // A reused skipped node (a comment) is not part of the node being
|
||||
+ // reduced: like a shifted skipped token, it leaves reducePos alone.
|
||||
+ let end = this.pos = start + value.length;
|
||||
+ if (!value.type.isSkipped)
|
||||
+ this.reducePos = end;
|
||||
this.pushState(next, start);
|
||||
this.buffer.push(index, start, end, -1 /* size == -1 means this is a reused value */);
|
||||
if (this.curContext)
|
||||
Створено
+27
-26
@@ -9,6 +9,7 @@ overrides:
|
||||
|
||||
patchedDependencies:
|
||||
'@codemirror/view': 0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5
|
||||
'@lezer/lr': 1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8
|
||||
|
||||
importers:
|
||||
|
||||
@@ -82,7 +83,7 @@ importers:
|
||||
version: 1.2.5
|
||||
'@lezer/lr':
|
||||
specifier: ^1.4.11
|
||||
version: 1.4.11
|
||||
version: 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@plutojl/lang-julia':
|
||||
specifier: ^1.2.0
|
||||
version: 1.2.0
|
||||
@@ -2408,7 +2409,7 @@ snapshots:
|
||||
'@codemirror/language': 6.13.1
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2467,7 +2468,7 @@ snapshots:
|
||||
'@codemirror/view': 6.43.14(patch_hash=0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5)
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2480,7 +2481,7 @@ snapshots:
|
||||
'@codemirror/language': 6.13.1
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2491,7 +2492,7 @@ snapshots:
|
||||
'@codemirror/view': 6.43.14(patch_hash=0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5)
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2539,7 +2540,7 @@ snapshots:
|
||||
'@codemirror/state': 6.7.6
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2548,14 +2549,14 @@ snapshots:
|
||||
'@codemirror/language': 6.13.1
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
'@codemirror/language': 6.13.1
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2573,7 +2574,7 @@ snapshots:
|
||||
'@codemirror/state': 6.7.6
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/yaml': 1.0.4
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
@@ -2609,7 +2610,7 @@ snapshots:
|
||||
'@codemirror/view': 6.43.14(patch_hash=0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5)
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
style-mod: 4.1.4
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
@@ -2745,24 +2746,24 @@ snapshots:
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
@@ -2772,27 +2773,27 @@ snapshots:
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
'@lezer/[email protected](patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
|
||||
@@ -2805,37 +2806,37 @@ snapshots:
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@marijn/[email protected]': {}
|
||||
|
||||
@@ -3101,7 +3102,7 @@ snapshots:
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@replit/[email protected]': {}
|
||||
|
||||
|
||||
@@ -5,3 +5,4 @@ overrides:
|
||||
mermaid>katex: ^0.18.2
|
||||
patchedDependencies:
|
||||
"@codemirror/view": patches/@codemirror__view.patch
|
||||
"@lezer/lr": patches/@lezer__lr.patch
|
||||
@@ -41,6 +41,7 @@ ide-core.workspace = true
|
||||
ide-cli.workspace = true
|
||||
dunce.workspace = true
|
||||
ide-clipboard.workspace = true
|
||||
ide-drag-out.workspace = true
|
||||
ide-fonts.workspace = true
|
||||
ide-text.workspace = true
|
||||
ide-vfs.workspace = true
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
//! Native window drag started from the web title bar.
|
||||
//! Native drags started from the web UI: the window from its title bar, files out to other apps.
|
||||
|
||||
use ide_command::desktop_command;
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use std::path::PathBuf;
|
||||
use tauri::WebviewWindow;
|
||||
|
||||
/// Starts dragging `window` while the primary mouse button is still down; returns whether a drag began.
|
||||
@@ -20,4 +21,41 @@ pub fn window_start_drag(window: WebviewWindow) -> IdeResult<bool> {
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
ide_command::desktop_domain!(window_start_drag);
|
||||
/// Drags `paths` (local files and folders) out of `window` while the primary mouse button is
|
||||
/// still down, so the app they are dropped on copies them (#2867). Resolves when the drag ends,
|
||||
/// with whether a target took the files.
|
||||
#[desktop_command(trust = always)]
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub async fn window_drag_files(window: WebviewWindow, paths: Vec<PathBuf>) -> IdeResult<bool> {
|
||||
let paths = ide_drag_out::local_paths(paths)?;
|
||||
let (started_tx, started_rx) = tokio::sync::oneshot::channel();
|
||||
let (done_tx, done_rx) = tokio::sync::oneshot::channel();
|
||||
let source = window.clone();
|
||||
window
|
||||
.run_on_main_thread(move || {
|
||||
let done = move |outcome| {
|
||||
let _ = done_tx.send(outcome);
|
||||
};
|
||||
// A tap WebKit delivered late: nothing is held, so the drag would never end.
|
||||
#[cfg(target_os = "macos")]
|
||||
if objc2_app_kit::NSEvent::pressedMouseButtons() & 1 == 0 {
|
||||
let _ = started_tx.send(Ok(()));
|
||||
return;
|
||||
}
|
||||
#[cfg(target_os = "linux")]
|
||||
let started = source
|
||||
.gtk_window()
|
||||
.map_err(|error| std::io::Error::other(error.to_string()))
|
||||
.and_then(|gtk_window| ide_drag_out::start(>k_window, paths, done));
|
||||
#[cfg(any(windows, target_os = "macos"))]
|
||||
let started = ide_drag_out::start(&source, paths, done);
|
||||
let _ = started_tx.send(started);
|
||||
})
|
||||
.map_err(|error| IdeError::internal(format!("Cannot start a drag on the main thread: {error}")))?;
|
||||
started_rx.await.map_err(|error| IdeError::internal(error.to_string()))??;
|
||||
// Dropped without an outcome when the drag never began or its backend lost it.
|
||||
Ok(matches!(done_rx.await, Ok(ide_drag_out::Outcome::Dropped)))
|
||||
}
|
||||
|
||||
ide_command::desktop_domain!(window_start_drag, window_drag_files);
|
||||
@@ -1,4 +1,8 @@
|
||||
use ide_core::{EventSink, IdeEvent};
|
||||
use ide_core::{EventSink, IdeEvent, SharedSink};
|
||||
use parking_lot::Mutex;
|
||||
use std::collections::{HashMap, VecDeque};
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use tauri::{AppHandle, Emitter, Manager, UserAttentionType};
|
||||
|
||||
/// Name of the single backend → UI event. Payload: [`IdeEvent`].
|
||||
@@ -38,6 +42,103 @@ pub struct TauriSink {
|
||||
pub window: Option<String>,
|
||||
}
|
||||
|
||||
const COALESCE_WINDOW: Duration = Duration::from_millis(16);
|
||||
const MAX_PENDING_DIAGNOSTICS: usize = 4096;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
||||
struct DiagnosticKey {
|
||||
path: ide_core::IpcPath,
|
||||
source: String,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct PendingDiagnostics {
|
||||
order: VecDeque<DiagnosticKey>,
|
||||
events: HashMap<DiagnosticKey, IdeEvent>,
|
||||
scheduled: bool,
|
||||
}
|
||||
|
||||
fn diagnostic_key(event: &IdeEvent) -> Option<DiagnosticKey> {
|
||||
let IdeEvent::Diagnostics { path, source, .. } = event else {
|
||||
return None;
|
||||
};
|
||||
Some(DiagnosticKey { path: path.clone(), source: source.clone() })
|
||||
}
|
||||
|
||||
fn take_pending(state: &mut PendingDiagnostics) -> Vec<IdeEvent> {
|
||||
let mut events = Vec::with_capacity(state.events.len());
|
||||
for key in state.order.drain(..) {
|
||||
if let Some(event) = state.events.remove(&key) {
|
||||
events.push(event);
|
||||
}
|
||||
}
|
||||
events
|
||||
}
|
||||
|
||||
/// Collapses repeated full-replacement diagnostics for one `(path, source)` into the
|
||||
/// latest event in a frame-sized window. Any other event flushes the pending
|
||||
/// diagnostics first so lifecycle and ordered events cannot overtake them.
|
||||
pub fn coalescing_sink(sink: SharedSink, runtime: tokio::runtime::Handle) -> SharedSink {
|
||||
let pending = Arc::new(Mutex::new(PendingDiagnostics::default()));
|
||||
let dispatch = Arc::new(Mutex::new(()));
|
||||
Arc::new(move |event| {
|
||||
let Some(key) = diagnostic_key(&event) else {
|
||||
let _dispatch = dispatch.lock();
|
||||
let events = take_pending(&mut pending.lock());
|
||||
for pending_event in events {
|
||||
sink.emit(pending_event);
|
||||
}
|
||||
sink.emit(event);
|
||||
return;
|
||||
};
|
||||
|
||||
loop {
|
||||
let schedule = {
|
||||
let mut state = pending.lock();
|
||||
if !state.events.contains_key(&key) && state.events.len() >= MAX_PENDING_DIAGNOSTICS {
|
||||
None
|
||||
} else {
|
||||
if !state.events.contains_key(&key) {
|
||||
state.order.push_back(key.clone());
|
||||
}
|
||||
state.events.insert(key.clone(), event.clone());
|
||||
if state.scheduled {
|
||||
return;
|
||||
}
|
||||
state.scheduled = true;
|
||||
Some(())
|
||||
}
|
||||
};
|
||||
|
||||
if schedule.is_none() {
|
||||
let _dispatch = dispatch.lock();
|
||||
let events = take_pending(&mut pending.lock());
|
||||
for pending_event in events {
|
||||
sink.emit(pending_event);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
let pending = pending.clone();
|
||||
let dispatch = dispatch.clone();
|
||||
let sink = sink.clone();
|
||||
runtime.spawn(async move {
|
||||
tokio::time::sleep(COALESCE_WINDOW).await;
|
||||
let _dispatch = dispatch.lock();
|
||||
let events = {
|
||||
let mut state = pending.lock();
|
||||
state.scheduled = false;
|
||||
take_pending(&mut state)
|
||||
};
|
||||
for event in events {
|
||||
sink.emit(event);
|
||||
}
|
||||
});
|
||||
return;
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// A debug session stopped on a breakpoint: bounce/flash the taskbar icon
|
||||
/// (IDEA) unless the user is already looking at an OpenIDEA window. The focus
|
||||
/// check and the request both touch the windowing system, so they run on the
|
||||
@@ -94,3 +195,205 @@ impl EventSink for TauriSink {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use ide_core::{Diagnostic, IpcPath, Pos, Range, Severity, TaskId};
|
||||
use parking_lot::Mutex;
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::time::Duration;
|
||||
use std::time::Instant;
|
||||
|
||||
fn setup() -> (ide_core::SharedSink, Arc<Mutex<Vec<IdeEvent>>>) {
|
||||
let events = Arc::new(Mutex::new(Vec::new()));
|
||||
let saved = events.clone();
|
||||
(coalescing_sink(Arc::new(move |event| saved.lock().push(event)), tokio::runtime::Handle::current()), events)
|
||||
}
|
||||
|
||||
fn diagnostics(path: &str, source: &str, message: &str) -> IdeEvent {
|
||||
IdeEvent::Diagnostics {
|
||||
path: IpcPath::from(path),
|
||||
source: source.into(),
|
||||
items: vec![Diagnostic {
|
||||
range: Range::point(Pos::new(0, 0)),
|
||||
severity: Severity::Error,
|
||||
message: message.into(),
|
||||
source: None,
|
||||
code: None,
|
||||
unnecessary: false,
|
||||
deprecated: false,
|
||||
server: None,
|
||||
}],
|
||||
}
|
||||
}
|
||||
|
||||
fn task(message: &str, done: bool) -> IdeEvent {
|
||||
IdeEvent::Task {
|
||||
id: TaskId(1),
|
||||
title: "Indexing".into(),
|
||||
message: Some(message.into()),
|
||||
fraction: Some(if done { 1.0 } else { 0.5 }),
|
||||
done,
|
||||
cancellable: !done,
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn coalesces_diagnostics_by_path_and_source() {
|
||||
let (sink, events) = setup();
|
||||
for index in 0..100 {
|
||||
sink.emit(diagnostics("/p/a.rs", "rust-analyzer", &format!("old {index}")));
|
||||
}
|
||||
sink.emit(diagnostics("/p/a.rs", "eslint", "lint"));
|
||||
sink.emit(diagnostics("/p/b.rs", "rust-analyzer", "other"));
|
||||
|
||||
assert!(events.lock().is_empty());
|
||||
tokio::task::yield_now().await;
|
||||
tokio::time::sleep(Duration::from_millis(30)).await;
|
||||
tokio::task::yield_now().await;
|
||||
|
||||
{
|
||||
let saved_events = events.lock();
|
||||
assert_eq!(saved_events.len(), 3);
|
||||
assert!(matches!(
|
||||
&saved_events[0],
|
||||
IdeEvent::Diagnostics { path, source, items }
|
||||
if path == &IpcPath::from("/p/a.rs")
|
||||
&& source == "rust-analyzer"
|
||||
&& items[0].message == "old 99"
|
||||
));
|
||||
assert!(matches!(
|
||||
&saved_events[1],
|
||||
IdeEvent::Diagnostics { path, source, .. }
|
||||
if path == &IpcPath::from("/p/a.rs") && source == "eslint"
|
||||
));
|
||||
assert!(matches!(
|
||||
&saved_events[2],
|
||||
IdeEvent::Diagnostics { path, source, .. }
|
||||
if path == &IpcPath::from("/p/b.rs") && source == "rust-analyzer"
|
||||
));
|
||||
}
|
||||
|
||||
tokio::time::sleep(Duration::from_millis(30)).await;
|
||||
assert_eq!(events.lock().len(), 3);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn immediate_events_flush_pending_events_first() {
|
||||
let (sink, events) = setup();
|
||||
sink.emit(diagnostics("/p/a.rs", "rust-analyzer", "before"));
|
||||
sink.emit(diagnostics("/p/b.rs", "rust-analyzer", "other"));
|
||||
sink.emit(IdeEvent::SettingsChanged { key: "editor.fontSize".into() });
|
||||
|
||||
let events = events.lock();
|
||||
assert_eq!(events.len(), 3);
|
||||
assert!(matches!(&events[0], IdeEvent::Diagnostics { .. }));
|
||||
assert!(matches!(&events[1], IdeEvent::Diagnostics { .. }));
|
||||
assert!(matches!(&events[2], IdeEvent::SettingsChanged { .. }));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn lifecycle_events_remain_immediate() {
|
||||
let (sink, events) = setup();
|
||||
sink.emit(task("complete", true));
|
||||
let events = events.lock();
|
||||
assert_eq!(events.len(), 1);
|
||||
assert!(matches!(
|
||||
&events[0],
|
||||
IdeEvent::Task { message, done, .. }
|
||||
if message.as_deref() == Some("complete") && *done
|
||||
));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn diagnostic_buffer_cap_flushes_without_dropping() {
|
||||
let (sink, events) = setup();
|
||||
for index in 0..=MAX_PENDING_DIAGNOSTICS {
|
||||
sink.emit(diagnostics(&format!("/p/{index}.rs"), "rust-analyzer", "diagnostic"));
|
||||
}
|
||||
assert_eq!(events.lock().len(), MAX_PENDING_DIAGNOSTICS);
|
||||
|
||||
tokio::time::sleep(Duration::from_millis(30)).await;
|
||||
assert_eq!(events.lock().len(), MAX_PENDING_DIAGNOSTICS + 1);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
#[ignore = "run for before/after diagnostics transport measurements"]
|
||||
async fn diagnostics_coalescing_benchmark() {
|
||||
const FILES: usize = 2_000;
|
||||
const ROUNDS: usize = 10;
|
||||
let burst: Vec<IdeEvent> = (0..ROUNDS)
|
||||
.flat_map(|round| {
|
||||
(0..FILES).map(move |file| {
|
||||
diagnostics(&format!("/workspace/src/File{file}.rs"), "rust-analyzer", &format!("round-{round}"))
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
|
||||
let raw_events = Arc::new(AtomicUsize::new(0));
|
||||
let raw_count = raw_events.clone();
|
||||
let raw: SharedSink = Arc::new(move |event| {
|
||||
let encoded = serde_json::to_vec(&event).unwrap();
|
||||
raw_count.fetch_add(1, Ordering::Relaxed);
|
||||
std::hint::black_box(encoded.len());
|
||||
});
|
||||
let raw_started = Instant::now();
|
||||
for event in &burst {
|
||||
raw.emit(event.clone());
|
||||
}
|
||||
let raw_elapsed = raw_started.elapsed();
|
||||
assert_eq!(raw_events.load(Ordering::Relaxed), FILES * ROUNDS);
|
||||
|
||||
let coalesced_events = Arc::new(AtomicUsize::new(0));
|
||||
let delivered_state = Arc::new(Mutex::new(HashMap::<IpcPath, String>::new()));
|
||||
let coalesced_count = coalesced_events.clone();
|
||||
let delivered = delivered_state.clone();
|
||||
let target: SharedSink = Arc::new(move |event| {
|
||||
let encoded = serde_json::to_vec(&event).unwrap();
|
||||
coalesced_count.fetch_add(1, Ordering::Relaxed);
|
||||
if let IdeEvent::Diagnostics { path, items, .. } = event {
|
||||
delivered.lock().insert(path, items[0].message.clone());
|
||||
}
|
||||
std::hint::black_box(encoded.len());
|
||||
});
|
||||
let coalesced = coalescing_sink(target, tokio::runtime::Handle::current());
|
||||
let coalesced_started = Instant::now();
|
||||
for event in &burst {
|
||||
coalesced.emit(event.clone());
|
||||
}
|
||||
|
||||
let expected_last_round = format!("round-{}", ROUNDS - 1);
|
||||
let deadline = Instant::now() + Duration::from_secs(2);
|
||||
loop {
|
||||
let complete = {
|
||||
let delivered_state = delivered_state.lock();
|
||||
delivered_state.len() == FILES
|
||||
&& delivered_state.values().all(|message| message == &expected_last_round)
|
||||
};
|
||||
if complete {
|
||||
break;
|
||||
}
|
||||
assert!(Instant::now() < deadline, "diagnostics did not settle before benchmark timeout");
|
||||
tokio::time::sleep(Duration::from_millis(5)).await;
|
||||
}
|
||||
let coalesced_elapsed = coalesced_started.elapsed();
|
||||
|
||||
let coalesced_count = coalesced_events.load(Ordering::Relaxed);
|
||||
assert!(coalesced_count >= FILES);
|
||||
assert!(coalesced_count < FILES * ROUNDS);
|
||||
let delivered_state = delivered_state.lock();
|
||||
assert_eq!(delivered_state.len(), FILES);
|
||||
assert!(delivered_state.values().all(|message| message == &expected_last_round));
|
||||
println!(
|
||||
"diagnostics transport burst: raw_events={} raw_ms={:.2} coalesced_events={} \
|
||||
coalesced_total_ms={:.2} reduction_pct={:.1}",
|
||||
FILES * ROUNDS,
|
||||
raw_elapsed.as_secs_f64() * 1_000.0,
|
||||
coalesced_count,
|
||||
coalesced_elapsed.as_secs_f64() * 1_000.0,
|
||||
(1.0 - coalesced_count as f64 / (FILES * ROUNDS) as f64) * 100.0,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -288,6 +288,12 @@ pub fn run() {
|
||||
window_groups::frame_changed(window.app_handle(), window.label());
|
||||
}
|
||||
tauri::WindowEvent::Destroyed => {
|
||||
// Also release a view that failed during startup, before the parent could watch it.
|
||||
if let Some(state) = window.try_state::<AppState>()
|
||||
&& let Ok(project) = state.host.project(window.label())
|
||||
{
|
||||
project.agents.unsubscribe(window.label());
|
||||
}
|
||||
window_zoom::forget(window.label());
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
|
||||
@@ -4,9 +4,15 @@
|
||||
//! renderer, so that is done before the first web view is created. Turning the DMA-BUF
|
||||
//! renderer off also avoids it, but then WebKit paints on the CPU and a tool window drag
|
||||
//! stalls the UI for seconds; setting `WEBKIT_DISABLE_DMABUF_RENDERER=1` still does that.
|
||||
//!
|
||||
//! On Wayland, GTK's default input method goes through the compositor (text-input-v3).
|
||||
//! With IBus behind it, a dead key waiting for its second key makes WebKit collapse every
|
||||
//! new selection in the window to its caret (Select All, mouse drags, text fields) until a
|
||||
//! composition completes. GTK's own IBus module does not, so IBus sessions use that.
|
||||
|
||||
const DISABLE_DMABUF: &str = "WEBKIT_DISABLE_DMABUF_RENDERER";
|
||||
const DISABLE_EXPLICIT_SYNC: &str = "__NV_DISABLE_EXPLICIT_SYNC";
|
||||
const IM_MODULE: &str = "GTK_IM_MODULE";
|
||||
|
||||
/// Run before other threads start (`set_var`).
|
||||
#[cfg(target_os = "linux")]
|
||||
@@ -16,6 +22,35 @@ pub fn configure() {
|
||||
tracing::info!("Wayland with the NVIDIA driver: {DISABLE_EXPLICIT_SYNC}=1");
|
||||
unsafe { std::env::set_var(DISABLE_EXPLICIT_SYNC, "1") };
|
||||
}
|
||||
if use_ibus_module(|k| std::env::var(k).ok(), gtk_ibus_module_installed) {
|
||||
tracing::info!("Wayland with IBus: {IM_MODULE}=ibus");
|
||||
unsafe { std::env::set_var(IM_MODULE, "ibus") };
|
||||
}
|
||||
}
|
||||
|
||||
/// GTK 3's IBus input method module (`ibus-gtk3`), wherever the distribution keeps it.
|
||||
#[cfg(target_os = "linux")]
|
||||
fn gtk_ibus_module_installed() -> bool {
|
||||
const MODULE: &str = "gtk-3.0/3.0.0/immodules/im-ibus.so";
|
||||
let lib_dirs = ["/usr/lib", "/usr/lib64", "/usr/local/lib"];
|
||||
lib_dirs.iter().any(|dir| {
|
||||
let dir = std::path::Path::new(dir);
|
||||
dir.join(MODULE).exists()
|
||||
|| std::fs::read_dir(dir)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.flatten()
|
||||
.any(|multiarch| multiarch.path().join(MODULE).exists())
|
||||
})
|
||||
}
|
||||
|
||||
/// A Wayland session whose input method is IBus, unless the user chose a GTK module.
|
||||
fn use_ibus_module(var: impl Fn(&str) -> Option<String>, module_installed: impl FnOnce() -> bool) -> bool {
|
||||
if var(IM_MODULE).is_some_and(|v| !v.is_empty()) || !gdk_wayland(&var) {
|
||||
return false;
|
||||
}
|
||||
let ibus = var("XMODIFIERS").is_some_and(|v| v.split_whitespace().any(|m| m == "@im=ibus"));
|
||||
ibus && module_installed()
|
||||
}
|
||||
|
||||
/// Applies Appearance › Smooth scrolling to every new web view
|
||||
@@ -46,11 +81,15 @@ fn disable_explicit_sync(var: impl Fn(&str) -> Option<String>, nvidia: bool) ->
|
||||
if !nvidia || var(DISABLE_DMABUF).is_some() || var(DISABLE_EXPLICIT_SYNC).is_some() {
|
||||
return false;
|
||||
}
|
||||
gdk_wayland(&var)
|
||||
}
|
||||
|
||||
/// GDK will open a Wayland display (it tries the backends of `GDK_BACKEND` in order).
|
||||
fn gdk_wayland(var: &impl Fn(&str) -> Option<String>) -> bool {
|
||||
let wayland_display = var("WAYLAND_DISPLAY").is_some_and(|v| !v.is_empty());
|
||||
// GDK tries the backends of `GDK_BACKEND` in order.
|
||||
let gdk_wayland =
|
||||
let backend =
|
||||
var("GDK_BACKEND").is_none_or(|b| matches!(b.split(',').next().map(str::trim), Some("wayland" | "*" | "")));
|
||||
wayland_display && gdk_wayland
|
||||
wayland_display && backend
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -76,4 +115,26 @@ mod tests {
|
||||
assert!(!decide(&[("WAYLAND_DISPLAY", "wayland-0"), (DISABLE_DMABUF, "1")], true));
|
||||
assert!(!decide(&[("WAYLAND_DISPLAY", "wayland-0"), (DISABLE_EXPLICIT_SYNC, "0")], true));
|
||||
}
|
||||
|
||||
fn decide_im(vars: &[(&str, &str)], installed: bool) -> bool {
|
||||
use_ibus_module(|k| vars.iter().find(|(name, _)| *name == k).map(|(_, v)| v.to_string()), || installed)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn uses_the_ibus_module_on_wayland_with_ibus_only() {
|
||||
let gnome = [("WAYLAND_DISPLAY", "wayland-0"), ("XMODIFIERS", "@im=ibus")];
|
||||
assert!(decide_im(&gnome, true));
|
||||
assert!(decide_im(&[gnome[0], gnome[1], (IM_MODULE, "")], true));
|
||||
assert!(!decide_im(&gnome, false));
|
||||
assert!(!decide_im(&[("WAYLAND_DISPLAY", "wayland-0"), ("XMODIFIERS", "@im=fcitx")], true));
|
||||
assert!(!decide_im(&[("WAYLAND_DISPLAY", "wayland-0")], true));
|
||||
assert!(!decide_im(&[("DISPLAY", ":0"), ("XMODIFIERS", "@im=ibus")], true));
|
||||
assert!(!decide_im(&[gnome[0], gnome[1], ("GDK_BACKEND", "x11")], true));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn keeps_the_users_input_method_module() {
|
||||
let vars = [("WAYLAND_DISPLAY", "wayland-0"), ("XMODIFIERS", "@im=ibus"), (IM_MODULE, "wayland")];
|
||||
assert!(!decide_im(&vars, true));
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
use crate::events::TauriSink;
|
||||
use crate::events::{TauriSink, coalescing_sink};
|
||||
use ide_core::{EventSink, IdeEvent, IdeResult, SharedSink};
|
||||
use ide_language::{LanguageRegistry, Syntax};
|
||||
use ide_workspace::RecentProjects;
|
||||
@@ -83,9 +83,11 @@ impl AppState {
|
||||
tracing::info!("invalidated caches: {removed:?}");
|
||||
}
|
||||
ide_host::data_dirs::migrate(&data_dir, &local_data_dir);
|
||||
let global_sink: SharedSink = Arc::new(TauriSink { app: app.clone(), window: None });
|
||||
let runtime = tauri::async_runtime::handle().inner().clone();
|
||||
let global_sink = coalescing_sink(Arc::new(TauriSink { app: app.clone(), window: None }), runtime.clone());
|
||||
let languages = Arc::new(LanguageRegistry::load(Some(&config_dir.join("languages")))?);
|
||||
let sink_app = app.clone();
|
||||
let sink_runtime = runtime.clone();
|
||||
let host = Arc::new(Host::new(ide_host::HostConfig {
|
||||
config_dir: config_dir.clone(),
|
||||
data_dir: data_dir.clone(),
|
||||
@@ -93,10 +95,13 @@ impl AppState {
|
||||
languages: languages.clone(),
|
||||
syntax,
|
||||
sink_for: Box::new(move |window| {
|
||||
Arc::new(TauriSink { app: sink_app.clone(), window: Some(window.to_owned()) })
|
||||
coalescing_sink(
|
||||
Arc::new(TauriSink { app: sink_app.clone(), window: Some(window.to_owned()) }),
|
||||
sink_runtime.clone(),
|
||||
)
|
||||
}),
|
||||
owner: Self::owner_window,
|
||||
runtime: tauri::async_runtime::handle().inner().clone(),
|
||||
runtime,
|
||||
project_environment: false,
|
||||
}));
|
||||
let announce = global_sink.clone();
|
||||
|
||||
@@ -84,11 +84,16 @@ pub struct Launch {
|
||||
pub editor: Option<Box<EditorLaunch>>,
|
||||
}
|
||||
|
||||
/// A file opened in a lightweight editor window, with optional caret / selection (0-based).
|
||||
/// What a lightweight editor window shows: a file, with optional caret / selection (0-based), or
|
||||
/// the tab of another editor kind.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct EditorLaunch {
|
||||
pub path: ide_core::IpcPath,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub path: Option<ide_core::IpcPath>,
|
||||
/// The tab's editor input, as JSON.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub input: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub line: Option<u32>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
@@ -355,6 +360,12 @@ impl WindowsState {
|
||||
|
||||
pub fn take_launch(&self, label: &str) -> Option<Launch> {
|
||||
let mut launches = self.launches.lock();
|
||||
// Lightweight windows need their launch again when their webview reloads.
|
||||
if let Some(launch) = launches.get(label)
|
||||
&& launch.editor.is_some()
|
||||
{
|
||||
return Some(launch.clone());
|
||||
}
|
||||
let launch = launches.remove(label)?;
|
||||
if launch.project.is_some() || launch.remote.is_some() || !launch.files.is_empty() || launch.diff.is_some() {
|
||||
self.opening.lock().insert(label.to_owned(), launch.clone());
|
||||
@@ -2755,6 +2766,27 @@ mod tests {
|
||||
assert_eq!(st.take_launch("project-1"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn editor_launch_survives_webview_reload_until_window_closes() {
|
||||
let st = WindowsState::default();
|
||||
let launch = Launch {
|
||||
editor: Some(Box::new(EditorLaunch {
|
||||
path: None,
|
||||
input: Some(r#"{"kind":"agent-session","key":"agent:running-task"}"#.into()),
|
||||
line: None,
|
||||
column: None,
|
||||
end_line: None,
|
||||
end_column: None,
|
||||
})),
|
||||
..Default::default()
|
||||
};
|
||||
st.set_launch("editor-main-3", launch.clone());
|
||||
assert_eq!(st.take_launch("editor-main-3"), Some(launch.clone()));
|
||||
assert_eq!(st.take_launch("editor-main-3"), Some(launch));
|
||||
st.forget("editor-main-3");
|
||||
assert!(st.take_launch("editor-main-3").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_taken_launch_owns_its_window_until_completion() {
|
||||
for launch in [
|
||||
|
||||
@@ -6,6 +6,8 @@ agent_archive always project_host bin
|
||||
agent_base_text trusted project_host bindings async
|
||||
agent_cancel always project_host bindings sync
|
||||
agent_changes trusted project_host bindings async
|
||||
agent_cli_update trusted project_host bindings async
|
||||
agent_cli_update_check trusted project_host bindings async
|
||||
agent_commands always project_host bindings async
|
||||
agent_context_usage trusted project_host bindings async
|
||||
agent_create trusted project_host bindings async
|
||||
@@ -49,6 +51,7 @@ agent_stop_background always project_host bin
|
||||
agent_subscribe always project_host bindings sync
|
||||
agent_unarchive always project_host bindings sync
|
||||
agent_unqueue always project_host bindings sync
|
||||
agent_unsubscribe always project_host bindings sync
|
||||
analysis_locate_duplicates always project_host bindings async
|
||||
android_devices trusted desktop bindings async
|
||||
android_logcat trusted desktop bindings async
|
||||
@@ -727,6 +730,7 @@ web_url always project_host bin
|
||||
window_close_context always desktop bindings sync
|
||||
window_complete_launch always desktop bindings sync
|
||||
window_cycle always desktop bindings sync
|
||||
window_drag_files always desktop bindings async
|
||||
window_flash_taskbar always desktop bindings sync
|
||||
window_group_cancel_close always desktop bindings sync
|
||||
window_group_close always desktop bindings sync
|
||||
|
||||
+58
-7
@@ -33,6 +33,10 @@ export const commands = {
|
||||
"group" |
|
||||
/** What the last turn changed, against the checkout as that turn started. */
|
||||
"lastTurn" | null) => typedError<AgentChange[], IdeError>(__TAURI_INVOKE("agent_changes", { task, view })),
|
||||
/** Installs the exact version offered if the selected installation still matches. */
|
||||
agentCliUpdate: (provider: string, offer: AgentCliOffer, request: RequestId) => typedError<AgentCliUpdateResult, IdeError>(__TAURI_INVOKE("agent_cli_update", { provider, offer, request })),
|
||||
/** Checks the selected installation without modifying it. */
|
||||
agentCliUpdateCheck: (provider: string, request: RequestId) => typedError<AgentCliUpdateResult, IdeError>(__TAURI_INVOKE("agent_cli_update_check", { provider, request })),
|
||||
/**
|
||||
* Slash commands to complete for `provider` in `task`'s directory, or in the project
|
||||
* before a task exists (skills and custom commands on disk included).
|
||||
@@ -146,11 +150,16 @@ export const commands = {
|
||||
agentShell: (task: string, command: string, request: RequestId) => typedError<null, IdeError>(__TAURI_INVOKE("agent_shell", { task, command, request })),
|
||||
/** Stops one of the task's background tasks. */
|
||||
agentStopBackground: (task: string, background: string) => typedError<null, IdeError>(__TAURI_INVOKE("agent_stop_background", { task, background })),
|
||||
/** Streams the project's agent events to this window; returns every task. */
|
||||
agentSubscribe: (onEvent: Channel<AgentEvent_Deserialize>) => typedError<AgentTask_Serialize[], IdeError>(__TAURI_INVOKE("agent_subscribe", { onEvent })),
|
||||
/**
|
||||
* Streams the project's agent events to `subscriber`, one of the project's windows (a remote
|
||||
* host sees them all as one `window`); returns every task.
|
||||
*/
|
||||
agentSubscribe: (onEvent: Channel<AgentEvent_Deserialize>, subscriber: string) => typedError<AgentTask_Serialize[], IdeError>(__TAURI_INVOKE("agent_subscribe", { onEvent, subscriber })),
|
||||
agentUnarchive: (task: string) => typedError<null, IdeError>(__TAURI_INVOKE("agent_unarchive", { task })),
|
||||
/** Drops a queued message and returns it (to edit it). */
|
||||
agentUnqueue: (task: string, queued: string) => typedError<AgentQueued, IdeError>(__TAURI_INVOKE("agent_unqueue", { task, queued })),
|
||||
/** Stops the events of a window that closed. */
|
||||
agentUnsubscribe: (subscriber: string) => typedError<null, IdeError>(__TAURI_INVOKE("agent_unsubscribe", { subscriber })),
|
||||
/** Locate Duplicates over the files of `scope`. */
|
||||
analysisLocateDuplicates: (request: RequestId, scope: SearchScope, options: DuplicateOptions) => typedError<DuplicatesReport, IdeError>(__TAURI_INVOKE("analysis_locate_duplicates", { request, scope, options })),
|
||||
/** Devices `adb` knows about, online ones first. */
|
||||
@@ -1930,6 +1939,12 @@ export const commands = {
|
||||
windowCompleteLaunch: () => typedError<null, IdeError>(__TAURI_INVOKE("window_complete_launch")),
|
||||
/** Focuses the next / previous window (⌘` / ⇧⌘`). */
|
||||
windowCycle: (forward: boolean) => __TAURI_INVOKE<void>("window_cycle", { forward }),
|
||||
/**
|
||||
* Drags `paths` (local files and folders) out of `window` while the primary mouse button is
|
||||
* still down, so the app they are dropped on copies them (#2867). Resolves when the drag ends,
|
||||
* with whether a target took the files.
|
||||
*/
|
||||
windowDragFiles: (paths: string[]) => typedError<boolean, IdeError>(__TAURI_INVOKE("window_drag_files", { paths })),
|
||||
/**
|
||||
* Flash (`true`) or stop flashing (`false`) this window's taskbar button, like IDEA when a
|
||||
* breakpoint is hit while the window is in the background (macOS bounces the dock icon,
|
||||
@@ -2199,6 +2214,18 @@ export type AgentChangesView =
|
||||
/** What the last turn changed, against the checkout as that turn started. */
|
||||
"lastTurn";
|
||||
|
||||
export type AgentCliOffer = {
|
||||
current: string,
|
||||
latest: string,
|
||||
prefix: string,
|
||||
};
|
||||
|
||||
export type AgentCliUpdateResult = {
|
||||
status: "available",
|
||||
} & AgentCliOffer | {
|
||||
status: "permission",
|
||||
} & AgentCliOffer | ({ status: "current"; current: string }) & { code?: never } | ({ status: "channel"; current: string }) & { code?: never } | ({ status: "updated"; current: string }) & { code?: never } | ({ status: "unmanaged" }) & { code?: never; current?: never } | ({ status: "error"; code: string }) & { current?: never };
|
||||
|
||||
export type AgentCommand = {
|
||||
/** Without the leading `/`. */
|
||||
name: string,
|
||||
@@ -2555,6 +2582,8 @@ export type AgentProvider = {
|
||||
commandReadOnlyReason: AgentCommandReadOnlyReason | null,
|
||||
/** Whether the command was found (on `PATH`). */
|
||||
installed: boolean,
|
||||
/** The built-in command can be owned by a global npm package. */
|
||||
canCheckCliUpdate?: boolean,
|
||||
/** Environment variables it starts with (from its agent file). */
|
||||
env: { [key in string]: string },
|
||||
/** Settings (models, modes…) the agent offered last time it ran; empty before its first session. */
|
||||
@@ -3819,6 +3848,8 @@ export type Commit_Deserialize = {
|
||||
historyPath?: string | null,
|
||||
logPosition?: number | null,
|
||||
logTotal?: number | null,
|
||||
/** Newest committer time at or after this row if newer than the row's commit. */
|
||||
logMergeTimeMs?: number | null,
|
||||
graphBoundaryParents?: string[],
|
||||
/** Reachability from HEAD, computed independently of the visible filters. */
|
||||
onCurrentBranch?: boolean | null,
|
||||
@@ -3848,6 +3879,8 @@ export type Commit_Serialize = {
|
||||
historyPath?: string | null,
|
||||
logPosition?: number | null,
|
||||
logTotal?: number | null,
|
||||
/** Newest committer time at or after this row if newer than the row's commit. */
|
||||
logMergeTimeMs?: number | null,
|
||||
graphBoundaryParents?: string[],
|
||||
/** Reachability from HEAD, computed independently of the visible filters. */
|
||||
onCurrentBranch?: boolean | null,
|
||||
@@ -5610,21 +5643,34 @@ export type EditorGeneralSettings = {
|
||||
richTextCopy?: boolean,
|
||||
};
|
||||
|
||||
/** A file opened in a lightweight editor window, with optional caret / selection (0-based). */
|
||||
/**
|
||||
* What a lightweight editor window shows: a file, with optional caret / selection (0-based), or
|
||||
* the tab of another editor kind.
|
||||
*/
|
||||
export type EditorLaunch = EditorLaunch_Serialize | EditorLaunch_Deserialize;
|
||||
|
||||
/** A file opened in a lightweight editor window, with optional caret / selection (0-based). */
|
||||
/**
|
||||
* What a lightweight editor window shows: a file, with optional caret / selection (0-based), or
|
||||
* the tab of another editor kind.
|
||||
*/
|
||||
export type EditorLaunch_Deserialize = {
|
||||
path: IpcPath,
|
||||
path?: IpcPath | null,
|
||||
/** The tab's editor input, as JSON. */
|
||||
input?: string | null,
|
||||
line?: number | null,
|
||||
column?: number | null,
|
||||
endLine?: number | null,
|
||||
endColumn?: number | null,
|
||||
};
|
||||
|
||||
/** A file opened in a lightweight editor window, with optional caret / selection (0-based). */
|
||||
/**
|
||||
* What a lightweight editor window shows: a file, with optional caret / selection (0-based), or
|
||||
* the tab of another editor kind.
|
||||
*/
|
||||
export type EditorLaunch_Serialize = {
|
||||
path: IpcPath,
|
||||
path?: IpcPath | null,
|
||||
/** The tab's editor input, as JSON. */
|
||||
input?: string | null,
|
||||
line?: number | null,
|
||||
column?: number | null,
|
||||
endLine?: number | null,
|
||||
@@ -6264,9 +6310,12 @@ export type FoldRange = {
|
||||
kind: FoldKind,
|
||||
};
|
||||
|
||||
export type FoldingOutlineVisibility = "hover" | "always";
|
||||
|
||||
/** Editor › General › Code Folding. */
|
||||
export type FoldingSettings = {
|
||||
showOutline?: boolean,
|
||||
outlineVisibility?: FoldingOutlineVisibility,
|
||||
fileHeader?: boolean,
|
||||
imports?: boolean,
|
||||
docComments?: boolean,
|
||||
@@ -12382,6 +12431,8 @@ export type VcsRoot = {
|
||||
export type VcsSettings = {
|
||||
/** Colour folders that contain changed files (project tree, tabs). */
|
||||
showDirtyDirectories?: boolean,
|
||||
/** Diffs the user opens show in an editor tab; off, in a separate window. */
|
||||
diffAsEditorTab?: boolean,
|
||||
/** Stop file history (Show History) after `history_limit` commits. */
|
||||
limitHistory?: boolean,
|
||||
historyLimit?: number,
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import type { EditorInput } from "@/workbench/contributions";
|
||||
import { activateEditorWindow } from "./EditorWindow";
|
||||
|
||||
const boot = vi.hoisted(() => ({
|
||||
emit: vi.fn(async () => {}),
|
||||
prepare: vi.fn(async (input: EditorInput) => input),
|
||||
openInput: vi.fn(async (_input: EditorInput, _options: unknown) => {}),
|
||||
openFile: vi.fn(async () => {}),
|
||||
setProject: vi.fn(),
|
||||
takeLaunch: vi.fn(),
|
||||
}));
|
||||
vi.mock("@tauri-apps/api/event", () => ({ emitTo: boot.emit }));
|
||||
vi.mock("@tauri-apps/api/window", () => ({
|
||||
getCurrentWindow: () => ({
|
||||
label: "editor-main-3",
|
||||
onCloseRequested: async () => () => {},
|
||||
setTitle: async () => {},
|
||||
}),
|
||||
}));
|
||||
vi.mock("@/platform/ipc", () => ({
|
||||
commands: {
|
||||
windowTakeLaunch: boot.takeLaunch,
|
||||
projectCurrent: async () => ({ name: "Project", root: "/project", settings: {} }),
|
||||
},
|
||||
}));
|
||||
vi.mock("@/platform/context", () => ({ setContext: vi.fn() }));
|
||||
vi.mock("@/platform/project", () => ({ basename: (path: string) => path, useProject: { setState: boot.setProject } }));
|
||||
vi.mock("@/platform/remote", () => ({ restoreRemote: async () => {} }));
|
||||
vi.mock("@/platform/platformInfo", () => ({ usePlatform: vi.fn() }));
|
||||
vi.mock("@/ui", () => ({ Spinner: () => null, T: () => null, isPopupOpen: () => false }));
|
||||
vi.mock("@/workbench/contributions", () => ({
|
||||
editorService: () => ({ openInput: boot.openInput, openFile: boot.openFile }),
|
||||
notifications: () => ({ notify: vi.fn() }),
|
||||
useContributions: {
|
||||
getState: () => ({ editorKinds: new Map([["agent-session", { prepareWindowInput: boot.prepare }]]) }),
|
||||
},
|
||||
}));
|
||||
vi.mock("@/workbench/EditorArea", () => ({ EditorArea: () => null }));
|
||||
vi.mock("@/workbench/OverlayHost", () => ({ OverlayHost: () => null }));
|
||||
vi.mock("@/workbench/TitleBar", () => ({ TitleBar: () => null }));
|
||||
vi.mock("@/workbench/WindowResizeHandles", () => ({ WindowResizeHandles: () => null }));
|
||||
vi.mock("@/workbench/theme", () => ({ useApplyTheme: () => {} }));
|
||||
vi.mock("@/workbench/messages", () => ({ ask: vi.fn() }));
|
||||
vi.mock("./controller", () => ({ editorController: vi.fn(), tabTitle: () => "Conversation" }));
|
||||
|
||||
let stop: (() => void) | undefined;
|
||||
const input: EditorInput = { kind: "agent-session", key: "agent:one", data: { task: "one" } };
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
boot.takeLaunch.mockResolvedValue({ editor: { input: JSON.stringify(input) } });
|
||||
});
|
||||
afterEach(() => stop?.());
|
||||
|
||||
describe("lightweight window handoff", () => {
|
||||
it("opens and reports ready only after its kind prepared the input", async () => {
|
||||
let ready!: (input: EditorInput) => void;
|
||||
boot.prepare.mockImplementationOnce(
|
||||
() =>
|
||||
new Promise((resolve) => {
|
||||
ready = resolve;
|
||||
}),
|
||||
);
|
||||
stop = activateEditorWindow("main");
|
||||
await vi.waitFor(() => expect(boot.prepare).toHaveBeenCalledWith(input));
|
||||
expect(boot.openInput).not.toHaveBeenCalled();
|
||||
expect(boot.emit).not.toHaveBeenCalled();
|
||||
const recovered = { ...input, data: { task: "one", draft: { text: "Latest draft" } } };
|
||||
ready(recovered);
|
||||
await vi.waitFor(() =>
|
||||
expect(boot.emit).toHaveBeenCalledWith("main", "openidea://editor/ready", {
|
||||
label: "editor-main-3",
|
||||
path: input.key,
|
||||
ok: true,
|
||||
}),
|
||||
);
|
||||
expect(boot.openInput).toHaveBeenCalledWith(recovered, { focus: true });
|
||||
});
|
||||
|
||||
it("reports failure without opening a broken conversation", async () => {
|
||||
boot.prepare.mockRejectedValueOnce(new Error("Cannot load conversation"));
|
||||
stop = activateEditorWindow("main");
|
||||
await vi.waitFor(() =>
|
||||
expect(boot.emit).toHaveBeenCalledWith("main", "openidea://editor/ready", {
|
||||
label: "editor-main-3",
|
||||
path: input.key,
|
||||
ok: false,
|
||||
error: "Error: Cannot load conversation",
|
||||
}),
|
||||
);
|
||||
expect(boot.openInput).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
@@ -1,6 +1,6 @@
|
||||
/**
|
||||
* Lightweight editor window (`editor-<parent>-<n>`): one project file in a window of its own
|
||||
* ("Open in New Window" without a second workbench).
|
||||
* Lightweight editor window (`editor-<parent>-<n>`): one project file, or one tab of another
|
||||
* editor kind, in a window of its own ("Open in New Window" without a second workbench).
|
||||
*/
|
||||
import clsx from "clsx";
|
||||
import { create } from "zustand";
|
||||
@@ -15,14 +15,14 @@ import { basename, useProject } from "@/platform/project";
|
||||
import { restoreRemote } from "@/platform/remote";
|
||||
import { usePlatform } from "@/platform/platformInfo";
|
||||
import { Spinner, T, isPopupOpen } from "@/ui";
|
||||
import { editorService, notifications } from "@/workbench/contributions";
|
||||
import { editorService, notifications, useContributions, type EditorInput } from "@/workbench/contributions";
|
||||
import { EditorArea } from "@/workbench/EditorArea";
|
||||
import { OverlayHost } from "@/workbench/OverlayHost";
|
||||
import { TitleBar } from "@/workbench/TitleBar";
|
||||
import { WindowResizeHandles } from "@/workbench/WindowResizeHandles";
|
||||
import { useApplyTheme } from "@/workbench/theme";
|
||||
import { ask } from "@/workbench/messages";
|
||||
import { editorController } from "./controller";
|
||||
import { editorController, tabTitle } from "./controller";
|
||||
import type { DocModel } from "./model/document";
|
||||
import styles from "./EditorWindow.module.css";
|
||||
|
||||
@@ -71,7 +71,7 @@ async function settleUnsaved(models: DocModel[], project: string | null): Promis
|
||||
return answer.button === "save" || answer.button === "discard";
|
||||
}
|
||||
|
||||
/** Loads the launch's file into this window's editor. */
|
||||
/** Loads the launch's file or tab into this window's editor. */
|
||||
export function activateEditorWindow(parent: string): () => void {
|
||||
let projectName: string | null = null;
|
||||
const native = getCurrentWindow();
|
||||
@@ -131,14 +131,20 @@ export function activateEditorWindow(parent: string): () => void {
|
||||
try {
|
||||
await restoreRemote();
|
||||
const launch = (await commands.windowTakeLaunch())?.editor as EditorLaunch | null | undefined;
|
||||
if (!launch?.path) throw new Error(tx("Missing editor request"));
|
||||
path = launch.path;
|
||||
let input = launch?.input ? (JSON.parse(launch.input) as EditorInput) : null;
|
||||
path = launch?.path ?? input?.key ?? "";
|
||||
if (!launch || !path) throw new Error(tx("Missing editor request"));
|
||||
const project = await commands.projectCurrent();
|
||||
if (!project) throw new Error(tx("The editor’s project is no longer open"));
|
||||
projectName = project.name;
|
||||
// Settings only: restoring the project's editor session here would overwrite the main window's tabs.
|
||||
useProject.setState({ settings: project.settings });
|
||||
// Other editor kinds read the project; the controller leaves its saved tabs to the main window.
|
||||
useProject.setState(input ? { project, settings: project.settings } : { settings: project.settings });
|
||||
setContext("projectOpen", true);
|
||||
if (input) {
|
||||
const prepare = useContributions.getState().editorKinds.get(input.kind)?.prepareWindowInput;
|
||||
if (prepare) input = await prepare(input);
|
||||
}
|
||||
if (disposed) return;
|
||||
const selection =
|
||||
launch.line != null && launch.column != null
|
||||
? {
|
||||
@@ -147,9 +153,11 @@ export function activateEditorWindow(parent: string): () => void {
|
||||
...(launch.endLine != null ? { endLine: launch.endLine, endCol: launch.endColumn ?? 0 } : {}),
|
||||
}
|
||||
: undefined;
|
||||
await editorService().openFile(path, { focus: true, selection });
|
||||
if (input) await editorService().openInput(input, { focus: true });
|
||||
else await editorService().openFile(path, { focus: true, selection });
|
||||
useEditorWindow.setState({ path });
|
||||
showCaption(`${project.name} — ${basename(path)}`);
|
||||
const title = input ? tabTitle(input, useContributions.getState().editorKinds) : basename(path);
|
||||
showCaption(`${project.name} — ${title}`);
|
||||
await reportReady(parent, { path, ok: true });
|
||||
} catch (error) {
|
||||
const message = String(error);
|
||||
@@ -171,7 +179,7 @@ export function EditorWindow() {
|
||||
const ownTitleBar = usePlatform((s) => s.overlayTitleBar || s.framelessTitleBar);
|
||||
return (
|
||||
<main className={clsx(styles.window, os === "linux" && styles.edge)}>
|
||||
{ownTitleBar && <TitleBar minimal dialog title={title} />}
|
||||
{ownTitleBar && <TitleBar minimal title={title} />}
|
||||
{error ? (
|
||||
<div className={styles.error} role="alert">
|
||||
{error}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
/**
|
||||
* Folding: ranges from the backend (`doc_folding`, tree-sitter based) merged
|
||||
* with CodeMirror's syntax folding (`foldNodeProp`) as fallback, IDEA-style
|
||||
* chevrons in the gutter (open chevrons only on gutter hover).
|
||||
* chevrons in the gutter (open chevrons can be shown only on hover).
|
||||
*/
|
||||
import {
|
||||
EditorSelection,
|
||||
@@ -23,6 +23,7 @@ import {
|
||||
unfoldEffect,
|
||||
} from "@codemirror/language";
|
||||
import type { FoldRange } from "@/platform/ipc";
|
||||
import type { FoldingOutlineVisibility } from "@/bindings";
|
||||
import { enclosingCodeBlock } from "./caretCommands";
|
||||
import { regionMarkerAt, regionNameAt } from "./regions";
|
||||
|
||||
@@ -432,9 +433,10 @@ export const expandRecursively = (view: EditorView) =>
|
||||
view.state.selection.ranges.flatMap((r) => expandRecursivelyEffects(view.state, r.head)),
|
||||
);
|
||||
|
||||
function chevron(open: boolean): HTMLElement {
|
||||
function chevron(open: boolean, visibility: FoldingOutlineVisibility): HTMLElement {
|
||||
const span = document.createElement("span");
|
||||
span.className = open ? "cm-openidea-foldOpen" : "cm-openidea-foldClosed";
|
||||
span.classList.toggle("cm-openidea-foldOnHover", open && visibility === "hover");
|
||||
span.title = open ? "Collapse" : "Expand";
|
||||
const ns = "http://www.w3.org/2000/svg";
|
||||
const svg = document.createElementNS(ns, "svg");
|
||||
@@ -477,10 +479,14 @@ export function foldChipWidth(el: HTMLElement): number {
|
||||
return Math.round(chip.getBoundingClientRect().width);
|
||||
}
|
||||
|
||||
export function foldingExtension(showOutline = true): Extension {
|
||||
export function foldingExtension(showOutline = true, visibility: FoldingOutlineVisibility = "hover"): Extension {
|
||||
return [
|
||||
// The chevron column sits right of contributed icon gutters (IDEA new UI).
|
||||
showOutline ? Prec.lowest(foldGutter({ markerDOM: chevron, foldingChanged: backendFoldingChanged })) : [],
|
||||
showOutline
|
||||
? Prec.lowest(
|
||||
foldGutter({ markerDOM: (open) => chevron(open, visibility), foldingChanged: backendFoldingChanged }),
|
||||
)
|
||||
: [],
|
||||
backendFolds,
|
||||
backendFoldService,
|
||||
codeFolding({
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { ensureSyntaxTree, syntaxTree } from "@codemirror/language";
|
||||
import { javascript } from "@codemirror/lang-javascript";
|
||||
import { EditorState } from "@codemirror/state";
|
||||
|
||||
/** Functions with long doc comments: re-parsing reuses a whole comment as one node. */
|
||||
const source = Array.from(
|
||||
{ length: 5 },
|
||||
(_, i) =>
|
||||
`/**\n${Array.from({ length: 40 }, (_, j) => ` * line ${j} of the comment on f${i}\n`).join("")} */\n` +
|
||||
`export const f${i} = (a, b = {}) => {\n // body\n if (a) return b\n return a\n}\n\n`,
|
||||
).join("");
|
||||
|
||||
describe("incremental parsing (#4468)", () => {
|
||||
it("keeps a reused comment out of the declaration before it", () => {
|
||||
let state = EditorState.create({ doc: source, extensions: [javascript()] });
|
||||
ensureSyntaxTree(state, state.doc.length, 5000);
|
||||
// Reindenting, as a formatter does.
|
||||
const at = source.indexOf(" // body");
|
||||
state = state.update({ changes: { from: at, to: at + 4, insert: " " } }).state;
|
||||
const tree = ensureSyntaxTree(state, state.doc.length, 5000) ?? syntaxTree(state);
|
||||
const fresh = javascript().language.parser.parse(state.doc.toString());
|
||||
expect(tree.toString()).toBe(fresh.toString());
|
||||
expect(tree.topNode.firstChild?.name).toBe("BlockComment");
|
||||
expect(tree.topNode.firstChild?.from).toBe(0);
|
||||
});
|
||||
});
|
||||
@@ -276,7 +276,8 @@ export function distractionFreeExtension(
|
||||
}
|
||||
|
||||
export function foldingFor(settings: EditorSettings | undefined): Extension {
|
||||
return foldingExtension(prefsOf(settings).folding.showOutline);
|
||||
const { showOutline, outlineVisibility } = prefsOf(settings).folding;
|
||||
return foldingExtension(showOutline, outlineVisibility);
|
||||
}
|
||||
|
||||
export function caretFor(settings: EditorSettings | undefined): Extension {
|
||||
|
||||
@@ -303,9 +303,9 @@ export const openideaTheme = EditorView.theme({
|
||||
cursor: "pointer",
|
||||
transition: "opacity var(--dur-fast) var(--ease)",
|
||||
},
|
||||
".cm-foldGutter .cm-openidea-foldOpen": { opacity: "0", display: "inline-flex" },
|
||||
".cm-foldGutter .cm-openidea-foldClosed": { display: "inline-flex" },
|
||||
".cm-gutters:hover .cm-foldGutter .cm-openidea-foldOpen": { opacity: "1" },
|
||||
".cm-foldGutter .cm-openidea-foldOpen, .cm-foldGutter .cm-openidea-foldClosed": { display: "inline-flex" },
|
||||
".cm-foldGutter .cm-openidea-foldOnHover": { opacity: "0" },
|
||||
".cm-gutters:hover .cm-foldGutter .cm-openidea-foldOnHover": { opacity: "1" },
|
||||
".cm-foldGutter .cm-gutterElement:hover": { color: "var(--fg-secondary)" },
|
||||
".cm-foldPlaceholder": {
|
||||
backgroundColor: "var(--editor-fold-chip)",
|
||||
|
||||
@@ -54,6 +54,7 @@ import { hoverActionsAt } from "@/platform/hoverActions";
|
||||
import { save as saveFileDialog, type DialogFilter as SaveDialogFilter } from "@/platform/dialog";
|
||||
import { isUntitledUri, untitledTitle } from "@/platform/virtualDocs";
|
||||
import { isRemoteWindow } from "@/platform/remote";
|
||||
import { auxiliaryWindow } from "@/platform/auxWindow";
|
||||
import { fileIconName, showContextMenu, type MenuItem } from "@/ui";
|
||||
import { canOpenWithSystemApp, canRevealInFileManager, fileManagerName } from "@/platform/fileManager";
|
||||
import {
|
||||
@@ -663,6 +664,8 @@ export class EditorController implements SlotHost {
|
||||
|
||||
/** Reopens the tabs, splits and carets saved for `root` (after the project opened). */
|
||||
async restoreSession(root: string) {
|
||||
// The project window owns the saved layout; a lightweight window shows what it was opened for.
|
||||
if (auxiliaryWindow()) return;
|
||||
this.sessionRoot = root;
|
||||
// A window close dropped this session: the next open starts from the tabs opened now.
|
||||
if (this.forgottenSessions.delete(root)) return;
|
||||
@@ -1913,6 +1916,8 @@ export class EditorController implements SlotHost {
|
||||
/** Open a lightweight aux editor (or a full window outside the project), then remove the original tab. */
|
||||
async detachTab(paneId: string, tabId: string): Promise<boolean> {
|
||||
const tab = useTabs.getState().panes[paneId]?.tabs.find((t) => t.id === tabId);
|
||||
const moves = tab && useContributions.getState().editorKinds.get(tab.input.kind)?.openInWindow;
|
||||
if (moves) return moves(tab.input);
|
||||
const path = tab?.input.path;
|
||||
if (
|
||||
!tab ||
|
||||
@@ -1981,6 +1986,11 @@ export class EditorController implements SlotHost {
|
||||
},
|
||||
});
|
||||
}
|
||||
/** Shows `input` in a lightweight window of this project; resolves to the window's label once it is shown. */
|
||||
openInWindow(input: EditorInput): Promise<string> {
|
||||
if (!isTauri() || isRemoteWindow()) return Promise.reject(new Error(t("app.window.desktopOnly")));
|
||||
return openLightweightEditor({ input: JSON.stringify(input) }, windowBackgroundHex(), input.key);
|
||||
}
|
||||
/** IDEA "Open in Opposite Group": the tab stays and a copy opens next door (or in a new split). */
|
||||
openInOpposite(paneId: string, tabId: string) {
|
||||
const s = useTabs.getState();
|
||||
@@ -2294,8 +2304,9 @@ export class EditorController implements SlotHost {
|
||||
{ label: "Unsplit All", run: () => void this.unsplitAll(paneId) },
|
||||
] as MenuItem[])
|
||||
: []),
|
||||
...(tab.input.path &&
|
||||
(tab.input.kind === "file" || documentLifecycle(tab.input, useContributions.getState().editorKinds))
|
||||
...(useContributions.getState().editorKinds.get(tab.input.kind)?.openInWindow ||
|
||||
(tab.input.path &&
|
||||
(tab.input.kind === "file" || documentLifecycle(tab.input, useContributions.getState().editorKinds)))
|
||||
? ([{ label: "Open in New Window", run: () => void this.detachTab(paneId, tab.id) }] as MenuItem[])
|
||||
: []),
|
||||
{ kind: "separator" },
|
||||
|
||||
@@ -39,7 +39,7 @@ beforeEach(() => {
|
||||
status: "ok",
|
||||
data: { kind: "opened", label: "second" },
|
||||
});
|
||||
vi.spyOn(light, "openLightweightEditor").mockResolvedValue();
|
||||
vi.spyOn(light, "openLightweightEditor").mockResolvedValue("editor-main-1");
|
||||
});
|
||||
afterEach(() => {
|
||||
ctrl?.stop();
|
||||
@@ -51,6 +51,24 @@ afterEach(() => {
|
||||
});
|
||||
|
||||
describe("detachTab", () => {
|
||||
it("leaves the move to an editor kind that moves its own tabs", async () => {
|
||||
const openInWindow = vi.fn(async () => true);
|
||||
unregister = registerEditorKind({ kind: "chat", component: () => null, title: () => "Chat", openInWindow });
|
||||
ctrl = new EditorController(createMemoryBackend({}));
|
||||
ctrl.start();
|
||||
await ctrl.openInput({ kind: "chat", key: "chat:1", data: { id: 1 } }, { focus: false });
|
||||
const [pane, id] = current();
|
||||
expect(await ctrl.detachTab(pane, id)).toBe(true);
|
||||
expect(openInWindow).toHaveBeenCalledWith(expect.objectContaining({ key: "chat:1", data: { id: 1 } }));
|
||||
expect(light.openLightweightEditor).not.toHaveBeenCalled();
|
||||
await ctrl.openInWindow({ kind: "chat", key: "chat:1", data: { id: 1 } });
|
||||
expect(light.openLightweightEditor).toHaveBeenCalledWith(
|
||||
{ input: JSON.stringify({ kind: "chat", key: "chat:1", data: { id: 1 } }) },
|
||||
null,
|
||||
"chat:1",
|
||||
);
|
||||
});
|
||||
|
||||
it("moves a project file to a lightweight editor without saving first", async () => {
|
||||
useProject.setState({
|
||||
project: { root: "/p", workspace: { projects: ["/p"] } } as never,
|
||||
|
||||
@@ -45,6 +45,7 @@ export function activate(): void | (() => void) {
|
||||
provideEditorService({
|
||||
openFile: (path, options) => ctrl.openFile(path, options),
|
||||
openInput: (input, options) => ctrl.openInput(input, options),
|
||||
openInWindow: (input) => ctrl.openInWindow(input),
|
||||
openUntitled: (options) => ctrl.openUntitled(options),
|
||||
activePath: () => ctrl.activePath(),
|
||||
activeCursor: () => ctrl.activeCursor(),
|
||||
|
||||
@@ -5,18 +5,23 @@ import { call, commands, type EditorLaunch } from "@/platform/ipc";
|
||||
|
||||
const READY_MS = 30_000;
|
||||
|
||||
/** Opens a project-file aux editor and resolves once it has taken over the document. */
|
||||
export async function openLightweightEditor(launch: EditorLaunch, background: string | null): Promise<void> {
|
||||
/** Opens a lightweight editor window; resolves to its label once it shows the file or tab. */
|
||||
export async function openLightweightEditor(
|
||||
launch: EditorLaunch,
|
||||
background: string | null,
|
||||
/** What the window reports as shown: the file, or the key of the launch's tab. */
|
||||
target = launch.path,
|
||||
): Promise<string> {
|
||||
const parent = getCurrentWindow();
|
||||
let off: (() => void) | undefined;
|
||||
let timer: ReturnType<typeof setTimeout> | undefined;
|
||||
try {
|
||||
await new Promise<void>((resolve, reject) => {
|
||||
return await new Promise<string>((resolve, reject) => {
|
||||
timer = setTimeout(() => reject(new Error(tx("Timed out opening the editor window"))), READY_MS);
|
||||
void parent
|
||||
.listen<EditorReadyResult>(EDITOR_READY, ({ payload }) => {
|
||||
if (payload.path && payload.path !== launch.path) return;
|
||||
if (payload.ok) resolve();
|
||||
if (payload.path && payload.path !== target) return;
|
||||
if (payload.ok) resolve(payload.label);
|
||||
else reject(new Error(payload.error || tx("Could not open the editor window")));
|
||||
})
|
||||
.then((unlisten) => {
|
||||
|
||||
@@ -1,18 +1,22 @@
|
||||
.popup {
|
||||
max-width: min(90vw, 900px);
|
||||
padding: 0;
|
||||
.barPopup,
|
||||
.childPopup {
|
||||
width: max-content;
|
||||
overflow: hidden;
|
||||
font-size: var(--fs-chrome);
|
||||
}
|
||||
.root {
|
||||
outline: none;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
max-width: 900px;
|
||||
}
|
||||
.bar {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 0;
|
||||
padding: 3px 4px;
|
||||
min-width: 0;
|
||||
padding: var(--space-1);
|
||||
overflow-x: auto;
|
||||
scrollbar-width: thin;
|
||||
white-space: nowrap;
|
||||
}
|
||||
.segmentWrap {
|
||||
@@ -22,20 +26,20 @@
|
||||
}
|
||||
.sep {
|
||||
color: var(--fg-faint);
|
||||
margin: 0 1px;
|
||||
margin: 0 var(--space-0-5);
|
||||
}
|
||||
.segment {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
gap: 5px;
|
||||
gap: var(--space-1);
|
||||
max-width: min(288px, 55vw);
|
||||
height: var(--h-control-small);
|
||||
padding: 0 5px;
|
||||
padding: 0 var(--space-1-5);
|
||||
border: none;
|
||||
border-radius: var(--radius-small);
|
||||
background: transparent;
|
||||
color: var(--fg);
|
||||
font: inherit;
|
||||
font-size: var(--fs-ui);
|
||||
cursor: default;
|
||||
}
|
||||
.segment:hover {
|
||||
@@ -46,22 +50,28 @@
|
||||
background: var(--bg-list-selected);
|
||||
color: var(--fg-strong);
|
||||
}
|
||||
.childPopup {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
min-width: min(200px, calc(100vw - 12px));
|
||||
}
|
||||
.list {
|
||||
align-self: flex-start;
|
||||
min-width: 200px;
|
||||
max-height: 360px;
|
||||
overflow-y: auto;
|
||||
margin: 0 4px 4px;
|
||||
padding: 4px;
|
||||
border-top: 1px solid var(--border-popup);
|
||||
min-height: 0;
|
||||
min-width: 0;
|
||||
max-width: min(480px, calc(100vw - 14px));
|
||||
max-height: min(360px, 62vh);
|
||||
padding: var(--space-1);
|
||||
overflow: auto;
|
||||
overflow-x: hidden;
|
||||
outline: none;
|
||||
}
|
||||
.row {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: var(--space-1-5);
|
||||
gap: var(--space-1);
|
||||
height: var(--h-list-row);
|
||||
padding: 0 6px;
|
||||
border-radius: var(--radius-row);
|
||||
padding: 0 var(--space-2);
|
||||
border-radius: var(--radius-selection);
|
||||
color: var(--fg);
|
||||
white-space: nowrap;
|
||||
}
|
||||
@@ -70,31 +80,31 @@
|
||||
color: var(--fg-strong);
|
||||
}
|
||||
.rowLabel {
|
||||
min-width: 0;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
}
|
||||
.rowIcon {
|
||||
flex: none;
|
||||
}
|
||||
.empty {
|
||||
padding: 4px 6px;
|
||||
color: var(--fg-muted);
|
||||
}
|
||||
.childList {
|
||||
min-width: 200px;
|
||||
max-height: 360px;
|
||||
overflow-y: auto;
|
||||
padding: 4px;
|
||||
outline: none;
|
||||
}
|
||||
.childHeader {
|
||||
display: flex;
|
||||
flex: none;
|
||||
align-items: center;
|
||||
gap: var(--space-1-5);
|
||||
height: var(--h-list-row);
|
||||
padding: 0 6px;
|
||||
margin-bottom: 2px;
|
||||
gap: var(--space-1);
|
||||
max-width: min(480px, calc(100vw - 14px));
|
||||
height: calc(var(--h-list-row) + var(--space-2));
|
||||
padding: 0 var(--space-3);
|
||||
border-bottom: 1px solid var(--border-popup);
|
||||
color: var(--fg-muted);
|
||||
}
|
||||
.rowChevron {
|
||||
flex: none;
|
||||
margin-left: auto;
|
||||
color: var(--fg-faint);
|
||||
}
|
||||
@@ -4,13 +4,13 @@
|
||||
* (folder contents, file / symbol members); Enter on a child opens it (a
|
||||
* folder becomes the next segment), Escape closes the list, then the bar.
|
||||
*/
|
||||
import { useEffect, useLayoutEffect, useMemo, useRef, useState, type KeyboardEvent } from "react";
|
||||
import { useEffect, useId, useLayoutEffect, useMemo, useRef, useState, type KeyboardEvent } from "react";
|
||||
import clsx from "clsx";
|
||||
import { create } from "zustand";
|
||||
import { call, commands, isTauri, type OutlineItem } from "@/platform/ipc";
|
||||
import { projectFolder, useProject } from "@/platform/project";
|
||||
import { useProjectViewLead } from "@/workbench/contributions";
|
||||
import { Icon, Popup, T } from "@/ui";
|
||||
import { Icon, listNavigate, Popup, revealHorizontally, revealVertically, T } from "@/ui";
|
||||
import { editorController, useEditorStatus } from "../controller";
|
||||
import { useOutline } from "../model/document";
|
||||
import { symbolChain } from "./outline";
|
||||
@@ -64,6 +64,74 @@ function anchorPoint(): { x: number; y: number } {
|
||||
return r ? { x: r.left + 8, y: r.top + 4 } : { x: 80, y: 80 };
|
||||
}
|
||||
|
||||
function NavChildList({
|
||||
label,
|
||||
id,
|
||||
items,
|
||||
active,
|
||||
onSelect,
|
||||
onChoose,
|
||||
onKeyDown,
|
||||
}: {
|
||||
label: string;
|
||||
id: string;
|
||||
items: readonly NavChild[] | null;
|
||||
active: number;
|
||||
onSelect: (index: number) => void;
|
||||
onChoose: (child: NavChild) => void;
|
||||
onKeyDown?: (e: KeyboardEvent) => void;
|
||||
}) {
|
||||
const ref = useRef<HTMLDivElement>(null);
|
||||
useLayoutEffect(() => {
|
||||
const scroller = ref.current;
|
||||
const row = scroller?.querySelector<HTMLElement>('[aria-selected="true"]');
|
||||
if (!scroller || !row) return;
|
||||
const reveal = () => revealVertically(scroller, row);
|
||||
reveal();
|
||||
if (typeof ResizeObserver === "undefined") return;
|
||||
const resize = new ResizeObserver(reveal);
|
||||
resize.observe(scroller);
|
||||
return () => resize.disconnect();
|
||||
}, [active, items]);
|
||||
|
||||
return (
|
||||
<div
|
||||
ref={ref}
|
||||
id={id}
|
||||
className={styles.list}
|
||||
role="listbox"
|
||||
aria-label={label}
|
||||
aria-activedescendant={items?.[active] ? `${id}-${active}` : undefined}
|
||||
tabIndex={0}
|
||||
data-autofocus
|
||||
onKeyDown={onKeyDown}
|
||||
>
|
||||
{items?.length === 0 && (
|
||||
<div className={styles.empty}>
|
||||
<T>Nothing here</T>
|
||||
</div>
|
||||
)}
|
||||
{items?.map((child, i) => (
|
||||
<div
|
||||
key={`${child.path}:${child.label}:${i}`}
|
||||
id={`${id}-${i}`}
|
||||
role="option"
|
||||
aria-selected={i === active}
|
||||
className={clsx(styles.row, i === active && styles.rowActive)}
|
||||
onMouseEnter={() => onSelect(i)}
|
||||
onClick={() => onChoose(child)}
|
||||
>
|
||||
<Icon name={iconOf(child)} size={16} className={styles.rowIcon} />
|
||||
<span className={styles.rowLabel} title={child.label}>
|
||||
{child.label}
|
||||
</span>
|
||||
{child.kind === "dir" && <Icon name="chevron-right" size={12} className={styles.rowChevron} />}
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
function NavBar({ path, line, col, directory }: { path: string; line: number; col: number; directory: boolean }) {
|
||||
const project = useProject((s) => s.project);
|
||||
const outline = useOutline((s) => s[path]);
|
||||
@@ -77,11 +145,19 @@ function NavBar({ path, line, col, directory }: { path: string; line: number; co
|
||||
const [active, setActive] = useState(() =>
|
||||
Math.max(0, directory ? initial.length - 1 : initial.findIndex((s) => s.kind === "file")),
|
||||
);
|
||||
const [list, setList] = useState<{ seg: number; items: NavChild[]; active: number; left: number } | null>(null);
|
||||
const [list, setList] = useState<{ seg: number; items: NavChild[]; active: number } | null>(null);
|
||||
const [childAnchor, setChildAnchor] = useState<HTMLButtonElement | null>(null);
|
||||
const listId = useId();
|
||||
const [anchor] = useState(anchorPoint);
|
||||
const strip = useRef<HTMLDivElement>(null);
|
||||
const buttons = useRef<Array<HTMLButtonElement | null>>([]);
|
||||
const listRef = useRef<HTMLDivElement>(null);
|
||||
const request = useRef(0);
|
||||
const listSegment = list?.seg;
|
||||
|
||||
const closeList = () => {
|
||||
request.current++;
|
||||
setList(null);
|
||||
};
|
||||
|
||||
const openList = async (index: number, segs = segments) => {
|
||||
const seg = segs[index];
|
||||
@@ -92,7 +168,7 @@ function NavBar({ path, line, col, directory }: { path: string; line: number; co
|
||||
// Start on the child that leads to the next segment, like IDEA.
|
||||
const next = segs[index + 1];
|
||||
const at = next ? items.findIndex((c) => c.path === next.path && c.label === next.label) : -1;
|
||||
setList({ seg: index, items, active: Math.max(0, at), left: buttons.current[index]?.offsetLeft ?? 0 });
|
||||
setList({ seg: index, items, active: Math.max(0, at) });
|
||||
};
|
||||
|
||||
const choose = (child: NavChild) => {
|
||||
@@ -125,15 +201,14 @@ function NavBar({ path, line, col, directory }: { path: string; line: number; co
|
||||
let handled = true;
|
||||
if (e.key === "ArrowLeft") move(-1);
|
||||
else if (e.key === "ArrowRight") move(1);
|
||||
else if (e.key === "ArrowDown" && !list) void openList(active);
|
||||
else if (e.key === "ArrowDown" && list)
|
||||
setList({ ...list, active: Math.min(list.items.length - 1, list.active + 1) });
|
||||
else if (e.key === "ArrowUp" && list) setList({ ...list, active: Math.max(0, list.active - 1) });
|
||||
else if (e.key === "Enter" && list) {
|
||||
const child = list.items[list.active];
|
||||
if (child) choose(child);
|
||||
} else if (e.key === "Enter") void openList(active);
|
||||
else if (e.key === "Escape" && list) setList(null);
|
||||
else if (list) {
|
||||
const next = listNavigate(e.key, list);
|
||||
if (next !== null) setList({ ...list, active: next });
|
||||
else if (e.key === "Enter") {
|
||||
const child = list.items[list.active];
|
||||
if (child) choose(child);
|
||||
} else handled = false;
|
||||
} else if (e.key === "ArrowDown" || e.key === "Enter") void openList(active);
|
||||
else handled = false;
|
||||
if (handled) {
|
||||
e.preventDefault();
|
||||
@@ -142,11 +217,19 @@ function NavBar({ path, line, col, directory }: { path: string; line: number; co
|
||||
};
|
||||
|
||||
useLayoutEffect(() => {
|
||||
buttons.current[active]?.scrollIntoView?.({ block: "nearest", inline: "nearest" });
|
||||
}, [active]);
|
||||
useEffect(() => {
|
||||
listRef.current?.querySelector<HTMLElement>('[aria-selected="true"]')?.scrollIntoView?.({ block: "nearest" });
|
||||
}, [list]);
|
||||
const row = strip.current;
|
||||
const current = buttons.current[active];
|
||||
if (!row || !current) return;
|
||||
const reveal = () => revealHorizontally(row, current);
|
||||
reveal();
|
||||
if (typeof ResizeObserver === "undefined") return;
|
||||
const resize = new ResizeObserver(reveal);
|
||||
resize.observe(row);
|
||||
return () => resize.disconnect();
|
||||
}, [active, segments]);
|
||||
useLayoutEffect(() => {
|
||||
setChildAnchor(listSegment === undefined ? null : (buttons.current[listSegment] ?? null));
|
||||
}, [listSegment, segments]);
|
||||
|
||||
return (
|
||||
<Popup
|
||||
@@ -156,7 +239,7 @@ function NavBar({ path, line, col, directory }: { path: string; line: number; co
|
||||
offset={0}
|
||||
onClose={close}
|
||||
aria-label="Navigation bar"
|
||||
className={styles.popup}
|
||||
className={styles.barPopup}
|
||||
>
|
||||
<div
|
||||
className={styles.root}
|
||||
@@ -166,7 +249,7 @@ function NavBar({ path, line, col, directory }: { path: string; line: number; co
|
||||
role="toolbar"
|
||||
aria-label={tx("Navigation bar")}
|
||||
>
|
||||
<div className={styles.bar}>
|
||||
<div className={styles.bar} ref={strip}>
|
||||
{segments.map((s, i) => (
|
||||
<span key={`${i}:${s.path}:${s.label}`} className={styles.segmentWrap}>
|
||||
{i > 0 && <Icon name="chevron-right" size={12} className={styles.sep} />}
|
||||
@@ -176,44 +259,39 @@ function NavBar({ path, line, col, directory }: { path: string; line: number; co
|
||||
tabIndex={-1}
|
||||
className={clsx(styles.segment, i === active && styles.active)}
|
||||
aria-current={i === active ? "location" : undefined}
|
||||
aria-haspopup="listbox"
|
||||
aria-expanded={i === listSegment}
|
||||
aria-controls={i === listSegment ? listId : undefined}
|
||||
title={s.label}
|
||||
onClick={() => {
|
||||
setActive(i);
|
||||
void openList(i);
|
||||
}}
|
||||
>
|
||||
<Icon name={iconOf(s)} size={14} />
|
||||
<span>{s.label}</span>
|
||||
<Icon name={iconOf(s)} size={14} className={styles.rowIcon} />
|
||||
<span className={styles.rowLabel}>{s.label}</span>
|
||||
</button>
|
||||
</span>
|
||||
))}
|
||||
</div>
|
||||
{list && (
|
||||
<div
|
||||
ref={listRef}
|
||||
className={styles.list}
|
||||
style={{ marginLeft: list.left }}
|
||||
role="listbox"
|
||||
{list && childAnchor && (
|
||||
<Popup
|
||||
open
|
||||
anchor={childAnchor}
|
||||
placement="bottom-start"
|
||||
onClose={closeList}
|
||||
aria-label={tx("Children")}
|
||||
className={styles.childPopup}
|
||||
>
|
||||
{list.items.length === 0 && (
|
||||
<div className={styles.empty}>
|
||||
<T>Nothing here</T>
|
||||
</div>
|
||||
)}
|
||||
{list.items.map((c, i) => (
|
||||
<div
|
||||
key={`${c.path}:${c.label}:${i}`}
|
||||
role="option"
|
||||
aria-selected={i === list.active}
|
||||
className={clsx(styles.row, i === list.active && styles.rowActive)}
|
||||
onMouseEnter={() => setList({ ...list, active: i })}
|
||||
onClick={() => choose(c)}
|
||||
>
|
||||
<Icon name={iconOf(c)} size={14} />
|
||||
<span className={styles.rowLabel}>{c.label}</span>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
<NavChildList
|
||||
id={listId}
|
||||
label={tx("Children")}
|
||||
items={list.items}
|
||||
active={list.active}
|
||||
onSelect={(i) => setList({ ...list, active: i })}
|
||||
onChoose={choose}
|
||||
/>
|
||||
</Popup>
|
||||
)}
|
||||
</div>
|
||||
</Popup>
|
||||
@@ -228,10 +306,12 @@ function NavBar({ path, line, col, directory }: { path: string; line: number; co
|
||||
export function NavChildrenPopup({
|
||||
segment,
|
||||
anchor,
|
||||
openAbove = true,
|
||||
onClose,
|
||||
}: {
|
||||
segment: NavSegment;
|
||||
anchor: HTMLElement;
|
||||
openAbove?: boolean;
|
||||
onClose: () => void;
|
||||
}) {
|
||||
const [stack, setStack] = useState<NavSegment[]>([segment]);
|
||||
@@ -239,7 +319,7 @@ export function NavChildrenPopup({
|
||||
const outline = useOutline((s) => s[top.path]);
|
||||
const [loaded, setLoaded] = useState<{ top: NavSegment; items: NavChild[] } | null>(null);
|
||||
const [active, setActive] = useState(0);
|
||||
const listRef = useRef<HTMLDivElement>(null);
|
||||
const listId = useId();
|
||||
const items = loaded?.top === top ? loaded.items : null;
|
||||
|
||||
useEffect(() => {
|
||||
@@ -255,10 +335,6 @@ export function NavChildrenPopup({
|
||||
alive = false;
|
||||
};
|
||||
}, [top, outline]);
|
||||
useEffect(() => {
|
||||
listRef.current?.querySelector<HTMLElement>('[aria-selected="true"]')?.scrollIntoView?.({ block: "nearest" });
|
||||
}, [active, items]);
|
||||
|
||||
const choose = (child: NavChild) => {
|
||||
if (child.kind === "dir") return setStack((s) => [...s, { kind: "dir", path: child.path, label: child.label }]);
|
||||
onClose();
|
||||
@@ -270,10 +346,9 @@ export function NavChildrenPopup({
|
||||
};
|
||||
|
||||
const onKeyDown = (e: KeyboardEvent) => {
|
||||
const n = items?.length ?? 0;
|
||||
const next = items ? listNavigate(e.key, { items, active, wrap: true }) : null;
|
||||
let handled = true;
|
||||
if (e.key === "ArrowDown" && n) setActive((a) => (a + 1) % n);
|
||||
else if (e.key === "ArrowUp" && n) setActive((a) => (a - 1 + n) % n);
|
||||
if (next !== null) setActive(next);
|
||||
else if (e.key === "Enter" || (e.key === "ArrowRight" && items?.[active]?.kind === "dir")) {
|
||||
const child = items?.[active];
|
||||
if (child) choose(child);
|
||||
@@ -286,44 +361,31 @@ export function NavChildrenPopup({
|
||||
};
|
||||
|
||||
return (
|
||||
<Popup open anchor={anchor} placement="top-start" onClose={onClose} aria-label={top.label} className={styles.popup}>
|
||||
<div
|
||||
ref={listRef}
|
||||
className={styles.childList}
|
||||
role="listbox"
|
||||
aria-label={top.label}
|
||||
tabIndex={0}
|
||||
data-autofocus
|
||||
aria-activedescendant={items?.length ? `navbar-child-${active}` : undefined}
|
||||
<Popup
|
||||
open
|
||||
anchor={anchor}
|
||||
placement={openAbove ? "top-start" : "bottom-start"}
|
||||
onClose={onClose}
|
||||
aria-label={top.label}
|
||||
className={styles.childPopup}
|
||||
>
|
||||
{stack.length > 1 && (
|
||||
<div className={styles.childHeader}>
|
||||
<Icon name={iconOf(top)} size={16} className={styles.rowIcon} />
|
||||
<span className={styles.rowLabel} title={top.label}>
|
||||
{top.label}
|
||||
</span>
|
||||
</div>
|
||||
)}
|
||||
<NavChildList
|
||||
id={listId}
|
||||
label={top.label}
|
||||
items={items}
|
||||
active={active}
|
||||
onSelect={setActive}
|
||||
onChoose={choose}
|
||||
onKeyDown={onKeyDown}
|
||||
>
|
||||
{stack.length > 1 && (
|
||||
<div className={styles.childHeader}>
|
||||
<Icon name={iconOf(top)} size={14} />
|
||||
<span className={styles.rowLabel}>{top.label}</span>
|
||||
</div>
|
||||
)}
|
||||
{items?.length === 0 && (
|
||||
<div className={styles.empty}>
|
||||
<T>Nothing here</T>
|
||||
</div>
|
||||
)}
|
||||
{items?.map((c, i) => (
|
||||
<div
|
||||
key={`${c.path}:${c.label}:${i}`}
|
||||
id={`navbar-child-${i}`}
|
||||
role="option"
|
||||
aria-selected={i === active}
|
||||
className={clsx(styles.row, i === active && styles.rowActive)}
|
||||
onMouseEnter={() => setActive(i)}
|
||||
onClick={() => choose(c)}
|
||||
>
|
||||
<Icon name={iconOf(c)} size={14} />
|
||||
<span className={styles.rowLabel}>{c.label}</span>
|
||||
{c.kind === "dir" && <Icon name="chevron-right" size={12} className={styles.rowChevron} />}
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
/>
|
||||
</Popup>
|
||||
);
|
||||
}
|
||||
@@ -226,7 +226,15 @@ function BreadcrumbStrip({
|
||||
}
|
||||
|
||||
/** A row of crumbs; a segment with `nav` opens a popup of its children. */
|
||||
function CrumbNav({ segments, className }: { segments: Crumb[]; className?: string }) {
|
||||
function CrumbNav({
|
||||
segments,
|
||||
className,
|
||||
inStatusBar,
|
||||
}: {
|
||||
segments: Crumb[];
|
||||
className?: string;
|
||||
inStatusBar: boolean;
|
||||
}) {
|
||||
const [popup, setPopup] = useState<{ nav: NavSegment; anchor: HTMLElement } | null>(null);
|
||||
return (
|
||||
<BreadcrumbStrip
|
||||
@@ -261,7 +269,15 @@ function CrumbNav({ segments, className }: { segments: Crumb[]; className?: stri
|
||||
</Fragment>
|
||||
);
|
||||
})}
|
||||
{popup && <NavChildrenPopup segment={popup.nav} anchor={popup.anchor} onClose={() => setPopup(null)} />}
|
||||
{popup && (
|
||||
<NavChildrenPopup
|
||||
key={`${popup.nav.kind}:${popup.nav.path}:${popup.nav.label}`}
|
||||
segment={popup.nav}
|
||||
anchor={popup.anchor}
|
||||
openAbove={inStatusBar}
|
||||
onClose={() => setPopup(null)}
|
||||
/>
|
||||
)}
|
||||
</BreadcrumbStrip>
|
||||
);
|
||||
}
|
||||
@@ -311,7 +327,7 @@ export function Breadcrumbs({ className, inStatusBar = false }: { className?: st
|
||||
segments.push(projectCrumb(project ?? currentProject));
|
||||
}
|
||||
if (!segments.length) return null;
|
||||
return <CrumbNav segments={segments} className={className ?? styles.status} />;
|
||||
return <CrumbNav segments={segments} className={className ?? styles.status} inStatusBar={inStatusBar} />;
|
||||
}
|
||||
|
||||
/** The status bar instance of the navigation bar; renders only for `statusBar`. */
|
||||
|
||||
@@ -28,6 +28,7 @@ import {
|
||||
import {
|
||||
acceptCompletion,
|
||||
closeCompletion,
|
||||
completionStatus,
|
||||
currentCompletions,
|
||||
snippet,
|
||||
startCompletion,
|
||||
@@ -840,6 +841,38 @@ describe("completion footer", () => {
|
||||
view = null;
|
||||
});
|
||||
|
||||
it("formats partial results while the language server is still answering", async () => {
|
||||
let finishReply = () => {};
|
||||
const reply = new Promise((resolve) => {
|
||||
finishReply = () => resolve({ isIncomplete: false, items: [] });
|
||||
});
|
||||
setInvokeRoute((cmd) => (cmd === "lsp_completion" ? reply : Promise.resolve(null)));
|
||||
const source: CompletionSource = (ctx) => ({ from: ctx.pos, options: [{ label: "localSuggestion" }] });
|
||||
view = new EditorView({
|
||||
state: EditorState.create({
|
||||
doc: "thing.",
|
||||
selection: { anchor: 6 },
|
||||
extensions: [
|
||||
lspDoc.of({ doc: 902, path: "/p/Example.java", language: "java", uiMode: "Java", readOnly: false }),
|
||||
completionExtension(),
|
||||
EditorState.languageData.of(() => [{ openideaCompletion: source }]),
|
||||
],
|
||||
}),
|
||||
parent: document.body,
|
||||
});
|
||||
try {
|
||||
startCompletion(view);
|
||||
await vi.waitFor(() => {
|
||||
expect(completionStatus(view!.state)).toBe("pending");
|
||||
expect(document.querySelector(".cm-tooltip-autocomplete > .cm-lsp-completion-footer")).not.toBeNull();
|
||||
});
|
||||
} finally {
|
||||
closeCompletion(view);
|
||||
setInvokeRoute(null);
|
||||
finishReply();
|
||||
}
|
||||
});
|
||||
|
||||
it("stays below the list after CodeMirror rebuilds the options", async () => {
|
||||
const source: CompletionSource = (ctx) => ({
|
||||
from: ctx.pos,
|
||||
|
||||
@@ -25,7 +25,16 @@ import {
|
||||
type CompletionSource,
|
||||
} from "@codemirror/autocomplete";
|
||||
import { EditorSelection, EditorState, Prec, StateEffect, StateField, type Text } from "@codemirror/state";
|
||||
import { EditorView, ViewPlugin, getTooltip, keymap, showTooltip, type Rect, type ViewUpdate } from "@codemirror/view";
|
||||
import {
|
||||
EditorView,
|
||||
ViewPlugin,
|
||||
getTooltip,
|
||||
keymap,
|
||||
repositionTooltips,
|
||||
showTooltip,
|
||||
type Rect,
|
||||
type ViewUpdate,
|
||||
} from "@codemirror/view";
|
||||
import {
|
||||
call,
|
||||
commands,
|
||||
@@ -989,7 +998,14 @@ const completionPopup = ViewPlugin.fromClass(
|
||||
class {
|
||||
constructor(private view: EditorView) {}
|
||||
update(u: ViewUpdate) {
|
||||
if (completionStatus(u.state) !== "active") return;
|
||||
// The lookup can show partial results while another source is still pending.
|
||||
const popup = u.state
|
||||
.facet(showTooltip)
|
||||
.map((tooltip) => tooltip && getTooltip(this.view, tooltip))
|
||||
.find((tooltip) => tooltip?.dom.classList.contains("cm-lsp-completion"));
|
||||
if (!popup) return;
|
||||
popup.offset ??= { x: -completionLabelOffset, y: 0 };
|
||||
const t = popup.dom;
|
||||
this.view.requestMeasure({
|
||||
key: this,
|
||||
read: () => {
|
||||
@@ -1000,19 +1016,12 @@ const completionPopup = ViewPlugin.fromClass(
|
||||
};
|
||||
},
|
||||
write: ({ width, fontSize }) => {
|
||||
const popup = this.view.state
|
||||
.facet(showTooltip)
|
||||
.map((tooltip) => tooltip && getTooltip(this.view, tooltip))
|
||||
.find((tooltip) => tooltip?.dom.classList.contains("cm-lsp-completion"));
|
||||
if (!popup) return;
|
||||
// Apply the label alignment inside CodeMirror's viewport clamp.
|
||||
popup.offset = { x: -completionLabelOffset, y: 0 };
|
||||
const t = popup.dom;
|
||||
if (t.style.getPropertyValue("--cm-completion-max-width") !== width)
|
||||
t.style.setProperty("--cm-completion-max-width", width);
|
||||
if (!t.isConnected) return;
|
||||
const widthChanged = t.style.getPropertyValue("--cm-completion-max-width") !== width;
|
||||
if (widthChanged) t.style.setProperty("--cm-completion-max-width", width);
|
||||
// The body-level tooltip does not inherit the editor's temporary font zoom.
|
||||
if (t.style.getPropertyValue("--openidea-editor-font-size") !== fontSize)
|
||||
t.style.setProperty("--openidea-editor-font-size", fontSize);
|
||||
const fontChanged = t.style.getPropertyValue("--openidea-editor-font-size") !== fontSize;
|
||||
if (fontChanged) t.style.setProperty("--openidea-editor-font-size", fontSize);
|
||||
let footer = t.querySelector<HTMLElement>(":scope > .cm-lsp-completion-footer");
|
||||
if (!footer) {
|
||||
footer = document.createElement("div");
|
||||
@@ -1023,7 +1032,10 @@ const completionPopup = ViewPlugin.fromClass(
|
||||
}
|
||||
// CodeMirror appends a fresh list when the candidates change.
|
||||
const list = t.querySelector(":scope > ul");
|
||||
if (list && list.nextElementSibling !== footer) list.after(footer);
|
||||
const footerMoved = list && list.nextElementSibling !== footer;
|
||||
if (footerMoved) list.after(footer);
|
||||
// CodeMirror has already measured the lookup. Reposition it before this frame paints.
|
||||
if (widthChanged || fontChanged || footerMoved) repositionTooltips(this.view);
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
@@ -30,6 +30,7 @@ describe("pending hints", () => {
|
||||
vi.advanceTimersByTime(PENDING_HINT_DELAY_MS);
|
||||
expect(hint()).toBe("Waiting…");
|
||||
expect(document.querySelector<HTMLElement>(".cm-lsp-hint")?.dataset.pending).toBe("true");
|
||||
expect(document.querySelector(".cm-lsp-hint .cm-lsp-hint-spinner svg")).not.toBeNull();
|
||||
done();
|
||||
expect(hint()).toBeNull();
|
||||
});
|
||||
@@ -37,6 +38,7 @@ describe("pending hints", () => {
|
||||
it("marks only progress as pending", () => {
|
||||
showHint(view, "Done");
|
||||
expect(document.querySelector<HTMLElement>(".cm-lsp-hint")?.dataset.pending).toBeUndefined();
|
||||
expect(document.querySelector(".cm-lsp-hint-spinner")).toBeNull();
|
||||
});
|
||||
|
||||
it("puts what the hint answers in its data attributes", () => {
|
||||
|
||||
@@ -7,6 +7,7 @@ import { StateEffect, StateField, type Extension } from "@codemirror/state";
|
||||
import { EditorView, keymap, showTooltip, type Tooltip } from "@codemirror/view";
|
||||
import { Prec } from "@codemirror/state";
|
||||
import { txTemplate } from "@/platform/i18n";
|
||||
import { spinnerNode } from "@/ui/iconNode";
|
||||
|
||||
interface Hint {
|
||||
pos: number;
|
||||
@@ -48,6 +49,7 @@ const hintField = StateField.define<Hint | null>({
|
||||
Object.assign(dom.dataset, h.data);
|
||||
if (typeof h.content === "string") {
|
||||
dom.textContent = txTemplate(h.content);
|
||||
if (h.pending) dom.prepend(spinnerNode(12, "cm-lsp-hint-spinner"));
|
||||
return { dom };
|
||||
}
|
||||
const built = h.content();
|
||||
|
||||
@@ -4,7 +4,15 @@
|
||||
* history, `docs.ts`) and code.quickDefinition (⌥Space, definition source popup).
|
||||
*/
|
||||
import { EditorSelection } from "@codemirror/state";
|
||||
import { closeHoverTooltips, hasHoverTooltips, hoverTooltip, ViewPlugin, type EditorView } from "@codemirror/view";
|
||||
import {
|
||||
closeHoverTooltips,
|
||||
hasHoverTooltips,
|
||||
hoverTooltip,
|
||||
repositionTooltips,
|
||||
ViewPlugin,
|
||||
type EditorView,
|
||||
type TooltipView,
|
||||
} from "@codemirror/view";
|
||||
import type { Extension } from "@codemirror/state";
|
||||
import {
|
||||
commands,
|
||||
@@ -17,6 +25,7 @@ import {
|
||||
type RequestId,
|
||||
} from "@/platform/ipc";
|
||||
import { executeAction } from "@/platform/actions";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { shortcutLabel } from "@/platform/keymap";
|
||||
import { diagnosticsAt, type PlacedDiagnostic, type EditorDiagnostic } from "./diagnostics";
|
||||
import { isEmptyMarkup, languageForPath } from "./markdown";
|
||||
@@ -38,6 +47,7 @@ import { editorPrefs } from "@/platform/editorSettings";
|
||||
import { CONTRIBUTED_HOVER, contributedAtAll, type ContributedHover } from "@/editor/api";
|
||||
import { navigationModifierHeld, onNavigationModifier, pointerTarget } from "@/platform/navigationModifier";
|
||||
import { languageSemantics } from "./semantic";
|
||||
import { tooltipBounds } from "@/editor/core/cm/setup";
|
||||
|
||||
let hoverRequest: RequestId | null = null;
|
||||
|
||||
@@ -74,6 +84,26 @@ export async function requestHover(view: EditorView, pos: number): Promise<Hover
|
||||
}
|
||||
}
|
||||
|
||||
function diagnosticAction(label: string, shortcut: string | undefined, run: () => void): HTMLButtonElement {
|
||||
const button = document.createElement("button");
|
||||
button.type = "button";
|
||||
button.className = "cm-lsp-link-button";
|
||||
const text = document.createElement("span");
|
||||
text.className = "cm-lsp-diag-action-label";
|
||||
text.textContent = label;
|
||||
button.appendChild(text);
|
||||
if (shortcut) {
|
||||
const keys = document.createElement("span");
|
||||
keys.className = "cm-lsp-diag-shortcut";
|
||||
keys.textContent = shortcut;
|
||||
keys.setAttribute("aria-hidden", "true");
|
||||
button.appendChild(keys);
|
||||
}
|
||||
button.addEventListener("mousedown", (e) => e.preventDefault());
|
||||
button.addEventListener("click", run);
|
||||
return button;
|
||||
}
|
||||
|
||||
function renderDiagnostics(view: EditorView, diags: PlacedDiagnostic[]): HTMLElement {
|
||||
const box = document.createElement("div");
|
||||
box.className = "cm-lsp-hover-diagnostics";
|
||||
@@ -91,58 +121,39 @@ function renderDiagnostics(view: EditorView, diags: PlacedDiagnostic[]): HTMLEle
|
||||
msg.className = "cm-lsp-diag-message";
|
||||
msg.textContent = d.message;
|
||||
row.appendChild(msg);
|
||||
const meta = document.createElement("div");
|
||||
meta.className = "cm-lsp-diag-meta";
|
||||
if (d.source) {
|
||||
const src = document.createElement("span");
|
||||
src.className = "cm-lsp-diag-source";
|
||||
src.textContent = d.source;
|
||||
meta.appendChild(src);
|
||||
row.appendChild(src);
|
||||
}
|
||||
const fix = document.createElement("button");
|
||||
fix.type = "button";
|
||||
fix.className = "cm-lsp-link-button";
|
||||
const keys = shortcutLabel("code.showIntentions");
|
||||
fix.textContent = keys ? `More actions… ${keys}` : "More actions…";
|
||||
if (d.severity !== "hint") offerQuickFix(view, meta, fix, from, to, d);
|
||||
fix.addEventListener("mousedown", (e) => e.preventDefault());
|
||||
fix.addEventListener("click", () => {
|
||||
const actions = document.createElement("div");
|
||||
actions.className = "cm-lsp-diag-actions";
|
||||
const more = diagnosticAction(tx("More actions…"), shortcutLabel("code.showIntentions"), () => {
|
||||
view.dispatch({ selection: EditorSelection.cursor(from) });
|
||||
view.focus();
|
||||
void executeAction("code.showIntentions");
|
||||
});
|
||||
meta.appendChild(fix);
|
||||
row.appendChild(meta);
|
||||
actions.appendChild(more);
|
||||
if (d.severity !== "hint") offerQuickFix(view, more, from, to, d);
|
||||
row.appendChild(actions);
|
||||
box.appendChild(row);
|
||||
}
|
||||
return box;
|
||||
}
|
||||
|
||||
/** IDEA's hover link to the problem's preferred quick fix, shown once the server named one. */
|
||||
function offerQuickFix(
|
||||
view: EditorView,
|
||||
meta: HTMLElement,
|
||||
before: HTMLElement,
|
||||
from: number,
|
||||
to: number,
|
||||
diagnostic: EditorDiagnostic,
|
||||
) {
|
||||
function offerQuickFix(view: EditorView, before: HTMLElement, from: number, to: number, diagnostic: EditorDiagnostic) {
|
||||
const doc = view.state.doc;
|
||||
void quickFixesAt(view, from, to, diagnostic.problem)
|
||||
.then(([action]) => {
|
||||
if (!action || view.state.doc !== doc || !before.isConnected) return;
|
||||
const link = document.createElement("button");
|
||||
link.type = "button";
|
||||
link.className = "cm-lsp-link-button";
|
||||
const keys = shortcutLabel("code.applyQuickFix");
|
||||
link.textContent = keys ? `${action.title} ${keys}` : action.title;
|
||||
link.addEventListener("mousedown", (e) => e.preventDefault());
|
||||
link.addEventListener("click", () => {
|
||||
const link = diagnosticAction(action.title, shortcutLabel("code.applyQuickFix"), () => {
|
||||
view.dispatch({ effects: closeHoverTooltips });
|
||||
view.focus();
|
||||
void applyCodeAction(view, action);
|
||||
});
|
||||
meta.insertBefore(link, before);
|
||||
before.before(link);
|
||||
})
|
||||
.catch(() => {});
|
||||
}
|
||||
@@ -186,12 +197,26 @@ export async function hoverSource(view: EditorView, pos: number) {
|
||||
create: () => {
|
||||
const dom = document.createElement("div");
|
||||
dom.className = `cm-lsp-hover ${selectableText}`;
|
||||
if (diags.length) dom.appendChild(renderDiagnostics(view, diags));
|
||||
if (!entry) return { dom };
|
||||
const tooltip: TooltipView = { dom };
|
||||
if (diags.length) {
|
||||
dom.appendChild(renderDiagnostics(view, diags));
|
||||
const fit = ({ left, right }: { left: number; right: number }) => {
|
||||
const width = `${Math.max(0, Math.floor(right - left) - 2)}px`;
|
||||
if (dom.style.getPropertyValue("--cm-diagnostic-hover-width") === width) return false;
|
||||
dom.style.setProperty("--cm-diagnostic-hover-width", width);
|
||||
return true;
|
||||
};
|
||||
tooltip.mount = () => void fit(tooltipBounds(view));
|
||||
tooltip.positioned = (space) => {
|
||||
if (fit(space)) repositionTooltips(view);
|
||||
};
|
||||
}
|
||||
if (!entry) return tooltip;
|
||||
// The same documentation view as F1's popup: links open in place, ← / →, Edit Source.
|
||||
dom.classList.add("cm-lsp-hover-doc");
|
||||
const doc = hoverDoc(entry, () => view.dispatch({ effects: closeHoverTooltips }));
|
||||
return { dom, destroy: mountHoverDoc(dom.appendChild(document.createElement("div")), doc) };
|
||||
tooltip.destroy = mountHoverDoc(dom.appendChild(document.createElement("div")), doc);
|
||||
return tooltip;
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
Loaded 100 of 248 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача