дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-21 09:00:49 +02:00
Порівняти коміти
93
Коміти
| Автор | 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 | ||
|
|
deecdbbf4f | ||
|
|
802400c324 | ||
|
|
edc6a522ee | ||
|
|
0c7a278ca6 | ||
|
|
8c93136063 | ||
|
|
e20e7b04bc | ||
|
|
f325e8c9d6 | ||
|
|
84edcc03a4 | ||
|
|
4146ca2041 | ||
|
|
105c37360b | ||
|
|
567b432468 | ||
|
|
f13d2b46cd | ||
|
|
266bd35a3d | ||
|
|
330d45279b | ||
|
|
af0e9c9a55 | ||
|
|
0e1a5e47d3 | ||
|
|
5226443670 | ||
|
|
07191394a5 | ||
|
|
882a08c5a4 | ||
|
|
8b5a9f582f | ||
|
|
1a430e5fdb | ||
|
|
7b2ba44a8d | ||
|
|
e6905f288e | ||
|
|
1828601b2a | ||
|
|
463b13b6b5 | ||
|
|
84cdfa2136 | ||
|
|
2bb93366bb | ||
|
|
7ee0a99853 | ||
|
|
7f21fdbe4d | ||
|
|
d47e9688cb | ||
|
|
94e318e740 | ||
|
|
6303cd5aef | ||
|
|
748f567abc |
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);
|
||||
@@ -1557,6 +1571,18 @@ impl AgentManager {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn context_usage(&self, id: &str) -> IdeResult<AgentContextUsage> {
|
||||
let task = self.task(id)?;
|
||||
let live = task.live.lock().clone().ok_or_else(|| IdeError::unavailable("the agent session is offline"))?;
|
||||
if !live.capabilities.context_usage {
|
||||
return Err(IdeError::unavailable("this agent does not report context details"));
|
||||
}
|
||||
live.peer
|
||||
.request("_openidea/context_usage", json!({ "sessionId": live.session }), None)
|
||||
.await
|
||||
.map_err(|error| IdeError::internal(task.describe(error)))
|
||||
}
|
||||
|
||||
/// Stops background task `background` of task `id`.
|
||||
pub async fn stop_background(&self, id: &str, background: &str) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
@@ -1988,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();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3867,6 +3893,7 @@ fn capabilities_of(init: &acp::Negotiated) -> (AgentCapabilities, bool) {
|
||||
rollback: meta("/openidea/rollback"),
|
||||
steer: steer_method(init).is_some(),
|
||||
background_tasks: meta("/openidea/backgroundTasks"),
|
||||
context_usage: meta("/openidea/contextUsage"),
|
||||
};
|
||||
(capabilities, init.prompt("embeddedContext"))
|
||||
}
|
||||
|
||||
@@ -45,6 +45,8 @@ pub struct AgentCapabilities {
|
||||
pub steer: bool,
|
||||
/// It reports its background tasks and stops them one by one.
|
||||
pub background_tasks: bool,
|
||||
/// The connected agent can report a breakdown of its context window.
|
||||
pub context_usage: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
@@ -275,6 +277,24 @@ pub struct AgentUsage {
|
||||
pub cost: Option<Box<AgentCost>>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentContextUsage {
|
||||
pub categories: Vec<AgentContextCategory>,
|
||||
pub total_tokens: u32,
|
||||
pub max_tokens: u32,
|
||||
pub model: String,
|
||||
pub is_auto_compact_enabled: Option<bool>,
|
||||
pub auto_compact_threshold: Option<u32>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
pub struct AgentContextCategory {
|
||||
pub name: String,
|
||||
pub tokens: u32,
|
||||
pub kind: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentCost {
|
||||
@@ -594,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.
|
||||
|
||||
@@ -407,7 +407,7 @@ impl Shim {
|
||||
"promptCapabilities": { "image": true, "embeddedContext": true },
|
||||
"sessionCapabilities": { "fork": {} },
|
||||
"mcpCapabilities": { "stdio": true, "http": true, "sse": true },
|
||||
"_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true } },
|
||||
"_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true, "contextUsage": true } },
|
||||
},
|
||||
"agentInfo": { "name": "claude", "title": "Claude Code", "version": self.version() },
|
||||
"authMethods": [],
|
||||
@@ -492,6 +492,11 @@ impl Shim {
|
||||
session.steer(params.get("prompt").cloned().unwrap_or_default()).map_err(invalid)?;
|
||||
Ok(json!({}))
|
||||
}
|
||||
"_openidea/context_usage" => {
|
||||
let session = self.session(¶ms)?;
|
||||
let proc = session.st.lock().proc.clone().ok_or_else(|| internal("Claude Code is not running"))?;
|
||||
rt.block_on(proc.control(json!({ "subtype": "get_context_usage" }))).map_err(internal)
|
||||
}
|
||||
"_openidea/stop_task" => {
|
||||
let session = self.session(¶ms)?;
|
||||
let task = params.get("taskId").and_then(Value::as_str).ok_or_else(|| invalid("no taskId"))?;
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -92,6 +92,12 @@ pub enum IdeEvent {
|
||||
/// Text version when this transition occurred, including when it was saved.
|
||||
version: u32,
|
||||
},
|
||||
/// An open document's file changed on disk while the buffer had unsaved changes. The buffer
|
||||
/// keeps them (autosave leaves the file alone); the UI offers to load the disk version.
|
||||
DocDiskConflict {
|
||||
doc: DocId,
|
||||
path: String,
|
||||
},
|
||||
/// A complete workspace edit can be undone as one operation.
|
||||
WorkspaceEditApplied {
|
||||
id: u32,
|
||||
|
||||
@@ -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(),
|
||||
@@ -76,6 +79,8 @@ pub struct GitSettings {
|
||||
/// label is plain text and a click on it places the caret as past the line end.
|
||||
pub inline_blame_clickable: bool,
|
||||
pub show_branch_in_project_view: bool,
|
||||
/// Branch operations from the branches popup act on every repository of the project.
|
||||
pub sync_branch_operations: bool,
|
||||
/// Path to the git executable; empty = auto-detect.
|
||||
pub executable: String,
|
||||
/// Default of Update Project: `merge` | `rebase`.
|
||||
@@ -117,6 +122,7 @@ impl Default for GitSettings {
|
||||
inline_blame: false,
|
||||
inline_blame_clickable: true,
|
||||
show_branch_in_project_view: false,
|
||||
sync_branch_operations: true,
|
||||
executable: String::new(),
|
||||
update_method: "merge".into(),
|
||||
auto_update_on_push_rejected: false,
|
||||
@@ -609,3 +615,16 @@ impl Default for AgentSecuritySettings {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn git_settings_without_sync_key_execute_on_all_repositories() {
|
||||
let missing: GitSettings = serde_json::from_str("{}").unwrap();
|
||||
assert!(missing.sync_branch_operations);
|
||||
let off: GitSettings = serde_json::from_str(r#"{"syncBranchOperations":false}"#).unwrap();
|
||||
assert!(!off.sync_branch_operations);
|
||||
}
|
||||
}
|
||||
@@ -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, 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)]
|
||||
@@ -351,6 +411,13 @@ pub async fn agent_probe(host: &Host, window: &str, provider: String, refresh: b
|
||||
host.project(window)?.agents.probe(&provider, refresh).await
|
||||
}
|
||||
|
||||
/// Reads the running session's context categories without sending a prompt.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_context_usage(host: &Host, window: &str, task: String) -> IdeResult<AgentContextUsage> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.context_usage(&task).await
|
||||
}
|
||||
|
||||
/// Stops the task's current turn, or with `subagent` only that subagent's work.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
|
||||
@@ -1077,7 +1144,10 @@ ide_command::domain!(
|
||||
agent_archive,
|
||||
agent_base_text,
|
||||
agent_cancel,
|
||||
agent_context_usage,
|
||||
agent_changes,
|
||||
agent_cli_update,
|
||||
agent_cli_update_check,
|
||||
agent_commands,
|
||||
agent_create,
|
||||
agent_delete,
|
||||
@@ -1117,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"));
|
||||
}
|
||||
|
||||
@@ -70,6 +70,13 @@ pub async fn doc_save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
|
||||
}
|
||||
|
||||
/// Load Changes from Disk: discards the buffer's unsaved changes and reads its file again.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_reload_from_disk(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || project.documents.discard_and_reload(doc)).await
|
||||
}
|
||||
|
||||
/// An automatic save: `false` (nothing written) when the file changed on disk after the
|
||||
/// buffer was edited, which only an explicit save overwrites.
|
||||
#[command(trust = always)]
|
||||
@@ -120,6 +127,7 @@ ide_command::domain!(
|
||||
doc_edit,
|
||||
doc_open,
|
||||
doc_open_untitled,
|
||||
doc_reload_from_disk,
|
||||
doc_save,
|
||||
doc_autosave,
|
||||
doc_save_all,
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use super::*;
|
||||
use crate::{HostConfig, Project};
|
||||
use ide_core::{IdeEvent, TextChange, event::NotifyLevel};
|
||||
use ide_core::{IdeEvent, TextChange};
|
||||
use parking_lot::Mutex;
|
||||
use std::{path::Path, sync::Arc};
|
||||
|
||||
@@ -57,7 +57,9 @@ impl Fixture {
|
||||
self.events
|
||||
.lock()
|
||||
.iter()
|
||||
.filter(|e| matches!(e, IdeEvent::DocPatched { .. } | IdeEvent::DocDirty { .. } | IdeEvent::Notify { .. }))
|
||||
.filter(|e| {
|
||||
matches!(e, IdeEvent::DocPatched { .. } | IdeEvent::DocDirty { .. } | IdeEvent::DocDiskConflict { .. })
|
||||
})
|
||||
.cloned()
|
||||
.collect()
|
||||
}
|
||||
@@ -110,7 +112,7 @@ async fn dirty_document_keeps_edits_and_warns_once() {
|
||||
let loaded = f.project.documents.snapshot(original.id).unwrap();
|
||||
assert_eq!(loaded.text, "local original\n");
|
||||
assert!(loaded.dirty);
|
||||
assert!(matches!(f.document_events().as_slice(), [IdeEvent::Notify { level: NotifyLevel::Warning, .. }]));
|
||||
assert!(matches!(f.document_events().as_slice(), [IdeEvent::DocDiskConflict { .. }]));
|
||||
f.events.lock().clear();
|
||||
f.sync().await;
|
||||
assert!(f.document_events().is_empty());
|
||||
|
||||
@@ -122,28 +122,38 @@ pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) ->
|
||||
|
||||
/// The interpreter the project uses: the configured one, else its virtualenv.
|
||||
#[command(trust = trusted)]
|
||||
pub fn sdk_python_effective(host: &Host, window: &str, near: Option<PathBuf>) -> IdeResult<Option<ide_core::IpcPath>> {
|
||||
pub async fn sdk_python_effective(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
near: Option<PathBuf>,
|
||||
) -> IdeResult<Option<ide_core::IpcPath>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
let member = ide_workspace::workspace::Workspace::load(&project.root)?.and_then(|w| {
|
||||
let near = near.as_deref()?;
|
||||
w.projects.into_iter().filter(|root| near.starts_with(root)).max_by_key(|root| root.components().count())
|
||||
});
|
||||
let (root, settings) = match member {
|
||||
Some(root) => {
|
||||
let settings = ide_workspace::SettingsStore::load(&host.config_dir, Some(&root)).effective();
|
||||
(root, settings)
|
||||
}
|
||||
None => (project.root.clone(), project.settings.effective()),
|
||||
};
|
||||
// A member with no Python of its own falls back to the primary project's
|
||||
// (the same chain run configurations use), so every answer names one interpreter.
|
||||
let interpreter = ide_sdk::apply::python_interpreter_near(&root, near.as_deref(), &settings).or_else(|| {
|
||||
(root != project.root)
|
||||
.then(|| ide_sdk::apply::python_interpreter(&project.root, &project.settings.effective()))
|
||||
.flatten()
|
||||
});
|
||||
Ok(interpreter.map(Into::into))
|
||||
let (config_dir, project_root) = (host.config_dir.clone(), project.root.clone());
|
||||
// Loading a member's settings needs more stack than a sync command's main thread has left.
|
||||
tokio::task::spawn_blocking(move || {
|
||||
let member = ide_workspace::workspace::Workspace::load(&project_root).ok().flatten().and_then(|w| {
|
||||
let near = near.as_deref()?;
|
||||
w.projects.into_iter().filter(|root| near.starts_with(root)).max_by_key(|root| root.components().count())
|
||||
});
|
||||
let (root, settings) = match member {
|
||||
Some(root) => {
|
||||
let settings = ide_workspace::SettingsStore::load(&config_dir, Some(&root)).effective();
|
||||
(root, settings)
|
||||
}
|
||||
None => (project_root.clone(), project.settings.effective()),
|
||||
};
|
||||
// A member with no Python of its own falls back to the primary project's
|
||||
// (the same chain run configurations use), so every answer names one interpreter.
|
||||
let interpreter = ide_sdk::apply::python_interpreter_near(&root, near.as_deref(), &settings).or_else(|| {
|
||||
(root != project_root)
|
||||
.then(|| ide_sdk::apply::python_interpreter(&project_root, &project.settings.effective()))
|
||||
.flatten()
|
||||
});
|
||||
Ok(interpreter.map(Into::into))
|
||||
})
|
||||
.await
|
||||
.map_err(join_err)?
|
||||
}
|
||||
|
||||
/// The PHP interpreter chosen in Settings › Languages & Frameworks › PHP; `None`: the `php` on `PATH`.
|
||||
@@ -461,7 +471,7 @@ mod tests {
|
||||
host.open_project("main", &root).unwrap();
|
||||
let detected = sdk_detect(&host, "main", SdkKind::Python).await.unwrap();
|
||||
assert!(detected.iter().any(|s| s.path == sdk.path && s.name == sdk.name));
|
||||
assert_eq!(sdk_python_effective(&host, "main", None).unwrap(), Some(sdk.path));
|
||||
assert_eq!(sdk_python_effective(&host, "main", None).await.unwrap(), Some(sdk.path));
|
||||
assert!(sdk_python_interpreter(&host, "main", root.join("README.md")).await.unwrap().is_none());
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
@@ -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"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -191,6 +191,7 @@ pub fn client_accepts(event: &IdeEvent, trusted: bool) -> bool {
|
||||
| IdeEvent::ExcludedDirsChanged { .. }
|
||||
| IdeEvent::DocPatched { .. }
|
||||
| IdeEvent::DocDirty { .. }
|
||||
| IdeEvent::DocDiskConflict { .. }
|
||||
| IdeEvent::WorkspaceEditApplied { .. }
|
||||
| IdeEvent::DocLanguage { .. }
|
||||
| IdeEvent::Diagnostics { .. }
|
||||
|
||||
@@ -161,7 +161,7 @@ async fn light_notebooks_open_without_interpreter_detection_or_execution() {
|
||||
assert!(ops::notebook::notebook_save(&host, "main", notebook.id.clone()).await.is_ok());
|
||||
let error = ops::sdk::sdk_detect(&host, "main", ide_sdk::SdkKind::Python).await.unwrap_err();
|
||||
assert!(error.message.contains("Restricted Mode"));
|
||||
assert!(ops::sdk::sdk_python_effective(&host, "main", None).is_err());
|
||||
assert!(ops::sdk::sdk_python_effective(&host, "main", None).await.is_err());
|
||||
assert!(ops::sdk::sdk_locate_tools(&host, "main", vec!["prettier".into()], Some(root)).await.is_err());
|
||||
let error = ops::notebook::notebook_restart(&host, "main", notebook.id.clone()).await.unwrap_err();
|
||||
assert!(error.message.contains("Restricted Mode"));
|
||||
|
||||
@@ -351,7 +351,7 @@ async fn python_venv() {
|
||||
// The project's virtualenv: listed first, and the interpreter the project uses.
|
||||
let found = ops::sdk::sdk_detect(&p.host, WINDOW, ide_sdk::SdkKind::Python).await.unwrap();
|
||||
assert_eq!(found.first().map(|s| s.source.as_str()), Some("venv"), "{found:?}");
|
||||
let effective = ops::sdk::sdk_python_effective(&p.host, WINDOW, None).unwrap().expect("an interpreter");
|
||||
let effective = ops::sdk::sdk_python_effective(&p.host, WINDOW, None).await.unwrap().expect("an interpreter");
|
||||
assert!(effective.starts_with(p.root.join(".venv")), "{effective:?}");
|
||||
}
|
||||
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
@@ -199,7 +199,9 @@ async fn python_effective_interpreter_falls_back_to_the_primary_project() {
|
||||
host.trust.decide(&member, true, false).unwrap();
|
||||
host.open_project("main", &primary).unwrap();
|
||||
let python = |near: Option<&std::path::Path>| {
|
||||
ops::sdk::sdk_python_effective(&host, "main", near.map(|p| p.to_path_buf())).unwrap().map(|p| p.into_path_buf())
|
||||
futures::executor::block_on(ops::sdk::sdk_python_effective(&host, "main", near.map(|p| p.to_path_buf())))
|
||||
.unwrap()
|
||||
.map(|p| p.into_path_buf())
|
||||
};
|
||||
// The primary project's own virtualenv, and the bare member inheriting it.
|
||||
assert_eq!(python(Some(&primary)), Some(venv_python.clone()));
|
||||
@@ -217,6 +219,13 @@ async fn python_effective_interpreter_falls_back_to_the_primary_project() {
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(python(Some(&member.join("src"))), Some(configured));
|
||||
// A workspace file that fails to load (a corrupt one, say) falls back to the
|
||||
// primary project's interpreter instead of failing the whole command.
|
||||
let workspace_file = primary.join(ide_workspace::workspace::FILE);
|
||||
let valid = std::fs::read(&workspace_file).unwrap();
|
||||
std::fs::write(&workspace_file, b"{not json").unwrap();
|
||||
assert_eq!(python(Some(&member.join("src"))), Some(venv_python.clone()));
|
||||
std::fs::write(&workspace_file, valid).unwrap();
|
||||
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;
|
||||
|
||||
@@ -265,7 +265,7 @@ impl ProjectIndex {
|
||||
pub fn find_files(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
let recent = self.shared.recent.lock().clone();
|
||||
let d = self.shared.data.read();
|
||||
matching::find_files(&d, &matching::Recents::new(&recent), query, limit)
|
||||
matching::find_files(&d, &matching::Recents::new(&recent), query, Some(&self.root), limit)
|
||||
}
|
||||
|
||||
/// All indexed files with this exact basename, for resolving printed source locations.
|
||||
@@ -301,7 +301,7 @@ impl ProjectIndex {
|
||||
|
||||
/// Fuzzy search for folders that hold indexed files; `rel_path` ends in `/`.
|
||||
pub fn find_dirs(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
matching::find_dirs(&self.shared.data.read(), query, limit)
|
||||
matching::find_dirs(&self.shared.data.read(), query, Some(&self.root), limit)
|
||||
}
|
||||
|
||||
/// Fuzzy symbol search; CamelHump aware (`OCo` → `OrderController`).
|
||||
@@ -574,11 +574,11 @@ pub mod bench_support {
|
||||
}
|
||||
|
||||
pub fn find_files(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
matching::find_files(&self.data, &matching::Recents::new(&self.recent), query, limit)
|
||||
matching::find_files(&self.data, &matching::Recents::new(&self.recent), query, None, limit)
|
||||
}
|
||||
|
||||
pub fn find_dirs(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
matching::find_dirs(&self.data, query, limit)
|
||||
matching::find_dirs(&self.data, query, None, limit)
|
||||
}
|
||||
|
||||
pub fn find_symbols(&self, query: &str, filter: SymbolFilter, limit: usize) -> Vec<SymbolMatch> {
|
||||
|
||||
@@ -205,29 +205,67 @@ impl<'a> Recents<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
/// `Foo.kt:12:3` -> `Foo.kt`; `\` -> `/`; strips leading `./` and `/`.
|
||||
fn normalize_file_query(q: &str) -> String {
|
||||
/// `Foo.kt:12:3` -> `Foo.kt`; `\` -> `/`; a pasted absolute path under `root` -> its project-relative
|
||||
/// form; strips leading `./` and `/`.
|
||||
fn normalize_file_query(q: &str, root: Option<&Path>) -> String {
|
||||
let mut q = q.trim().replace('\\', "/");
|
||||
// `\\?\C:\a` (verbatim) and `\\.\C:\a` name `C:/a`.
|
||||
if let Some(rest) = verbatim_target(&q) {
|
||||
q = rest.to_owned();
|
||||
}
|
||||
while let Some((head, tail)) = q.rsplit_once(':')
|
||||
&& !tail.is_empty()
|
||||
&& tail.bytes().all(|b| b.is_ascii_digit())
|
||||
{
|
||||
q = head.to_owned();
|
||||
}
|
||||
if let Some(root) = root
|
||||
&& let Some(rel) = strip_root(&q, root)
|
||||
{
|
||||
q = rel;
|
||||
}
|
||||
let q = q.trim_start_matches("./").trim_start_matches('/');
|
||||
q.chars().filter(|c| !c.is_whitespace()).collect()
|
||||
}
|
||||
|
||||
/// Path a `\\?\` / `\\.\` verbatim prefix points at, for a `/`-separated path.
|
||||
fn verbatim_target(q: &str) -> Option<&str> {
|
||||
q.strip_prefix("//?/").or_else(|| q.strip_prefix("//./"))
|
||||
}
|
||||
|
||||
/// `q` (already `/`-separated) below `root`, without the separating slash. A drive-letter root
|
||||
/// compares like Windows, where case does not matter.
|
||||
fn strip_root(q: &str, root: &Path) -> Option<String> {
|
||||
let root = root.to_string_lossy().replace('\\', "/");
|
||||
let root = verbatim_target(&root).unwrap_or(&root);
|
||||
let root = root.trim_end_matches('/');
|
||||
let windows = root.as_bytes().get(1) == Some(&b':');
|
||||
let head = q.get(..root.len())?;
|
||||
if head != root && !(windows && head.eq_ignore_ascii_case(root)) {
|
||||
return None;
|
||||
}
|
||||
match q.get(root.len()..)? {
|
||||
"" => Some(String::new()),
|
||||
tail => tail.strip_prefix('/').map(str::to_owned),
|
||||
}
|
||||
}
|
||||
|
||||
enum FileQuery {
|
||||
Name(Needle),
|
||||
Path { dir: Needle, name: Needle },
|
||||
}
|
||||
|
||||
pub(crate) fn find_files(data: &IndexData, recents: &Recents, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
pub(crate) fn find_files(
|
||||
data: &IndexData,
|
||||
recents: &Recents,
|
||||
query: &str,
|
||||
root: Option<&Path>,
|
||||
limit: usize,
|
||||
) -> Vec<FileMatch> {
|
||||
if limit == 0 {
|
||||
return Vec::new();
|
||||
}
|
||||
let q = normalize_file_query(query);
|
||||
let q = normalize_file_query(query, root);
|
||||
if q.is_empty() {
|
||||
return recents
|
||||
.paths
|
||||
@@ -306,8 +344,8 @@ pub(crate) fn find_files(data: &IndexData, recents: &Recents, query: &str, limit
|
||||
|
||||
/// Fuzzy folder search over the folders holding indexed files: folder-name matches beat
|
||||
/// path matches; `/` in the query matches the whole path. `rel_path` ends in `/`.
|
||||
pub(crate) fn find_dirs(data: &IndexData, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
let q = normalize_file_query(query);
|
||||
pub(crate) fn find_dirs(data: &IndexData, query: &str, root: Option<&Path>, limit: usize) -> Vec<FileMatch> {
|
||||
let q = normalize_file_query(query, root);
|
||||
if limit == 0 || q.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
@@ -673,8 +711,18 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn normalizes_queries() {
|
||||
assert_eq!(normalize_file_query(" ./src\\main.rs:12:4 "), "src/main.rs");
|
||||
assert_eq!(normalize_file_query("/a b"), "ab");
|
||||
let root = Path::new("E:/work/sample");
|
||||
assert_eq!(normalize_file_query(" ./src\\main.rs:12:4 ", None), "src/main.rs");
|
||||
assert_eq!(normalize_file_query("/a b", None), "ab");
|
||||
// A pasted absolute path names an indexed file (#4079 follow-up).
|
||||
assert_eq!(normalize_file_query(r"E:\work\sample\pkg\Config.go", Some(root)), "pkg/Config.go");
|
||||
assert_eq!(normalize_file_query(r"e:/WORK/sample\pkg/Config.go", Some(root)), "pkg/Config.go");
|
||||
assert_eq!(normalize_file_query(r"\\?\E:\work\sample\src\App.kt", Some(root)), "src/App.kt");
|
||||
assert_eq!(normalize_file_query(r"E:\work\sample\pkg\Config.go:12:4", Some(root)), "pkg/Config.go");
|
||||
// Outside the project, and a POSIX root, keep the path as given.
|
||||
assert_eq!(normalize_file_query(r"E:\elsewhere\x.go", Some(root)), "E:/elsewhere/x.go");
|
||||
assert_eq!(normalize_file_query("/home/me/Src/a.rs", Some(Path::new("/home/me/src"))), "home/me/Src/a.rs");
|
||||
assert_eq!(normalize_file_query("/home/me/src/a.rs", Some(Path::new("/home/me/src"))), "a.rs");
|
||||
assert_eq!(split_symbol_query("Order.save"), (Some("Order"), "save"));
|
||||
assert_eq!(split_symbol_query("a::b::C::new"), (Some("C"), "new"));
|
||||
assert_eq!(split_symbol_query("save"), (None, "save"));
|
||||
|
||||
@@ -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 = {
|
||||
|
||||
@@ -190,6 +190,19 @@ fn file_ranking_is_idea_like() {
|
||||
assert_eq!(shown.to_lowercase(), "uibtn");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_pasted_absolute_path_finds_the_indexed_file() {
|
||||
let fx = sample();
|
||||
let idx = fx.open();
|
||||
let abs = fx.root.join("src/ui/Button.tsx");
|
||||
let abs = abs.to_string_lossy().into_owned();
|
||||
assert_eq!(files(&idx, &abs)[0], "src/ui/Button.tsx");
|
||||
// A trailing `:line:col`, and a path outside the project that names no file.
|
||||
assert_eq!(files(&idx, &format!("{abs}:12:4"))[0], "src/ui/Button.tsx");
|
||||
let outside = fx.root.parent().unwrap().join("elsewhere/Button.tsx");
|
||||
assert!(files(&idx, &outside.to_string_lossy()).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn find_dirs_ranks_folder_names() {
|
||||
let f = sample();
|
||||
|
||||
@@ -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> {
|
||||
|
||||
@@ -25,7 +25,7 @@ impl LspManager {
|
||||
/// Whether jdtls serves the Java files of `path`. Without it, launches build with the
|
||||
/// build tool and take the classpath from [`Self::java_server_classpath`] or the build model.
|
||||
pub fn java_served_by_jdtls(&self, path: &Path) -> bool {
|
||||
self.servers_for(&LanguageId::new("java"), path).iter().any(|s| s.name == JDTLS)
|
||||
self.servers_for(&LanguageId::new("java"), path).iter().any(|s| s.name == JDTLS && !s.gave_up())
|
||||
}
|
||||
|
||||
/// The java-analyzer executable among the Java servers of `path`, whatever the server is
|
||||
@@ -107,6 +107,27 @@ fn is_java_analyzer(binary: &Path) -> bool {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::server::Conn;
|
||||
use ide_core::event::ServerStatus;
|
||||
use ide_language::LanguageRegistry;
|
||||
use std::sync::Arc;
|
||||
|
||||
#[test]
|
||||
fn missing_jdtls_leaves_java_analyzer_to_serve_the_module() {
|
||||
let project = tempfile::tempdir().unwrap();
|
||||
let root = project.path();
|
||||
let manager =
|
||||
LspManager::new(root.to_path_buf(), Arc::new(LanguageRegistry::load(None).unwrap()), Arc::new(|_| {}));
|
||||
assert!(manager.java_served_by_jdtls(root));
|
||||
assert!(manager.java_analyzer_binary(root).is_none());
|
||||
|
||||
let jdtls = manager.servers_for(&LanguageId::new("java"), root).into_iter().find(|s| s.name == JDTLS).unwrap();
|
||||
let generation = jdtls.begin_start().unwrap();
|
||||
assert!(jdtls.fail_start(generation, Conn::Missing, manager.sink(), ServerStatus::Missing, None));
|
||||
|
||||
assert!(!manager.java_served_by_jdtls(root));
|
||||
assert_eq!(manager.java_analyzer_binary(root).as_deref(), Some(Path::new("java-analyzer")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recognises_java_analyzer_by_its_executable() {
|
||||
|
||||
@@ -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(()) }
|
||||
})
|
||||
|
||||
@@ -349,64 +349,9 @@ impl RemoteService {
|
||||
progress: &mut (dyn FnMut(&str, usize, usize) + Send),
|
||||
) -> IdeResult<TransferReport> {
|
||||
let fs = self.fs(connection).await?;
|
||||
let mut report = TransferReport::default();
|
||||
let mut folders = Vec::new();
|
||||
let mut jobs = Vec::new();
|
||||
for remote in remotes {
|
||||
let Some(top) = download_target(dir, remote, remote) else {
|
||||
report.skipped += 1;
|
||||
continue;
|
||||
};
|
||||
match fs.stat(remote).await {
|
||||
Ok(Some(e)) if e.is_dir => {
|
||||
folders.push(top);
|
||||
let mut entries = Vec::new();
|
||||
if let Err(e) = remote_tree(&fs, remote, cancel, &mut entries).await {
|
||||
report.fail(remote.clone(), e);
|
||||
}
|
||||
for entry in entries {
|
||||
match download_target(dir, remote, &entry.path) {
|
||||
Some(local) if entry.is_dir => folders.push(local),
|
||||
Some(local) => jobs.push((entry.path, local)),
|
||||
None => report.skipped += 1,
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(Some(_)) => jobs.push((remote.clone(), top)),
|
||||
Ok(None) => report.fail(remote.clone(), IdeError::not_found(format!("{remote} does not exist"))),
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
let root = tokio::fs::canonicalize(dir).await?;
|
||||
for folder in &folders {
|
||||
if !stays_inside(&root, folder).await {
|
||||
report.fail(folder.display().to_string(), outside(folder));
|
||||
} else if let Err(e) = tokio::fs::create_dir_all(folder).await {
|
||||
report.fail(folder.display().to_string(), e.into());
|
||||
}
|
||||
}
|
||||
for (i, (remote, local)) in jobs.iter().enumerate() {
|
||||
if cancel.is_cancelled() {
|
||||
break;
|
||||
}
|
||||
progress(remote, i, jobs.len());
|
||||
if !stays_inside(&root, local).await {
|
||||
report.fail(remote.clone(), outside(local));
|
||||
continue;
|
||||
}
|
||||
if let Some(parent) = local.parent()
|
||||
&& let Err(e) = tokio::fs::create_dir_all(parent).await
|
||||
{
|
||||
report.fail(remote.clone(), e.into());
|
||||
continue;
|
||||
}
|
||||
match fs.download(remote, local).await {
|
||||
Ok(()) => report.files += 1,
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
let r = download_into(&fs, remotes, dir, cancel, progress).await;
|
||||
fs.close().await;
|
||||
Ok(report)
|
||||
r
|
||||
}
|
||||
|
||||
// --- save hook -----------------------------------------------------------------
|
||||
@@ -656,6 +601,75 @@ fn cache_key(connection: &FsConnection) -> String {
|
||||
}
|
||||
|
||||
/// Files and folders under remote folder `dir` (symlinked folders are not followed).
|
||||
/// `remotes` (folders recursively) into the local folder `dir`, each under its own name, without
|
||||
/// the remote path above it; existing files are replaced. Remote Host › Download to…, and the
|
||||
/// project view's Download to… in a remote project.
|
||||
pub async fn download_into(
|
||||
fs: &RemoteFs,
|
||||
remotes: &[String],
|
||||
dir: &Path,
|
||||
cancel: &CancellationToken,
|
||||
progress: &mut (dyn FnMut(&str, usize, usize) + Send),
|
||||
) -> IdeResult<TransferReport> {
|
||||
let mut report = TransferReport::default();
|
||||
let mut folders = Vec::new();
|
||||
let mut jobs = Vec::new();
|
||||
for remote in remotes {
|
||||
let Some(top) = download_target(dir, remote, remote) else {
|
||||
report.skipped += 1;
|
||||
continue;
|
||||
};
|
||||
match fs.stat(remote).await {
|
||||
Ok(Some(e)) if e.is_dir => {
|
||||
folders.push(top);
|
||||
let mut entries = Vec::new();
|
||||
if let Err(e) = remote_tree(fs, remote, cancel, &mut entries).await {
|
||||
report.fail(remote.clone(), e);
|
||||
}
|
||||
for entry in entries {
|
||||
match download_target(dir, remote, &entry.path) {
|
||||
Some(local) if entry.is_dir => folders.push(local),
|
||||
Some(local) => jobs.push((entry.path, local)),
|
||||
None => report.skipped += 1,
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(Some(_)) => jobs.push((remote.clone(), top)),
|
||||
Ok(None) => report.fail(remote.clone(), IdeError::not_found(format!("{remote} does not exist"))),
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
let root = tokio::fs::canonicalize(dir).await?;
|
||||
for folder in &folders {
|
||||
if !stays_inside(&root, folder).await {
|
||||
report.fail(folder.display().to_string(), outside(folder));
|
||||
} else if let Err(e) = tokio::fs::create_dir_all(folder).await {
|
||||
report.fail(folder.display().to_string(), e.into());
|
||||
}
|
||||
}
|
||||
for (i, (remote, local)) in jobs.iter().enumerate() {
|
||||
if cancel.is_cancelled() {
|
||||
break;
|
||||
}
|
||||
progress(remote, i, jobs.len());
|
||||
if !stays_inside(&root, local).await {
|
||||
report.fail(remote.clone(), outside(local));
|
||||
continue;
|
||||
}
|
||||
if let Some(parent) = local.parent()
|
||||
&& let Err(e) = tokio::fs::create_dir_all(parent).await
|
||||
{
|
||||
report.fail(remote.clone(), e.into());
|
||||
continue;
|
||||
}
|
||||
match fs.download(remote, local).await {
|
||||
Ok(()) => report.files += 1,
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
Ok(report)
|
||||
}
|
||||
|
||||
async fn remote_tree(
|
||||
fs: &RemoteFs,
|
||||
dir: &str,
|
||||
|
||||
@@ -631,9 +631,11 @@ fn spring_boot_apps(root: &Path, build: &Path, out: &mut Vec<RunConfig>) {
|
||||
}
|
||||
}
|
||||
|
||||
/// The module has main sources, and its build applies the Spring Boot plugin: its own build
|
||||
/// file, or a build above it in `build` that applies it to its modules (a parent POM's
|
||||
/// `<build><plugins>`, Gradle's `subprojects` / `allprojects`).
|
||||
/// The module has main sources and Spring Boot on its classpath, as far as its build files
|
||||
/// tell: its own build, or a build above it in `build` that hands Spring Boot to its modules,
|
||||
/// references it (a dependency, the starter parent, the BOM or the plugin). A Maven module that
|
||||
/// depends on Spring Boot through a parent or another module is a Spring Boot application even
|
||||
/// without the packaging plugin; only `<pluginManagement>` alone doesn't count.
|
||||
fn applies_spring_boot(build: &Path, module: &Path) -> bool {
|
||||
if !["java", "kotlin"].iter().any(|l| module.join("src/main").join(l).is_dir()) {
|
||||
return false;
|
||||
@@ -642,15 +644,19 @@ fn applies_spring_boot(build: &Path, module: &Path) -> bool {
|
||||
if pom.contains("<packaging>pom</packaging>") {
|
||||
return false;
|
||||
}
|
||||
if pom.contains("spring-boot-maven-plugin") {
|
||||
if references_spring_boot(&without_plugin_management(&pom)) {
|
||||
return true;
|
||||
}
|
||||
} else if GRADLE_BUILDS.iter().filter_map(|n| read(&module.join(n))).any(|text| applies_boot_gradle_plugin(&text)) {
|
||||
} else if GRADLE_BUILDS
|
||||
.iter()
|
||||
.filter_map(|n| read(&module.join(n)))
|
||||
.any(|text| applies_boot_gradle_plugin(&text) || text.contains("org.springframework.boot:"))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
module.ancestors().skip(1).take_while(|dir| dir.starts_with(build)).any(|dir| {
|
||||
if let Some(pom) = read(&dir.join("pom.xml")) {
|
||||
return without_plugin_management(&pom).contains("spring-boot-maven-plugin");
|
||||
return references_spring_boot(&without_plugin_management(&pom));
|
||||
}
|
||||
GRADLE_BUILDS.iter().filter_map(|n| read(&dir.join(n))).any(|text| {
|
||||
(text.contains("subprojects") || text.contains("allprojects")) && applies_boot_gradle_plugin(&text)
|
||||
@@ -658,6 +664,14 @@ fn applies_spring_boot(build: &Path, module: &Path) -> bool {
|
||||
})
|
||||
}
|
||||
|
||||
/// A POM (without its `<pluginManagement>`) referencing Spring Boot: a dependency or the parent
|
||||
/// (`org.springframework.boot`), a starter, the BOM import or the plugin.
|
||||
fn references_spring_boot(pom: &str) -> bool {
|
||||
["org.springframework.boot", "spring-boot-starter", "spring-boot-dependencies", "spring-boot-maven-plugin"]
|
||||
.iter()
|
||||
.any(|m| pom.contains(m))
|
||||
}
|
||||
|
||||
/// A Gradle build applying the plugin (`id("org.springframework.boot")`, `apply plugin: '…'`),
|
||||
/// not only depending on Spring Boot (`org.springframework.boot:…`).
|
||||
fn applies_boot_gradle_plugin(text: &str) -> bool {
|
||||
|
||||
@@ -938,7 +938,18 @@ fn launch_env(root: &Path, config: &RunConfig) -> IdeResult<LaunchEnv> {
|
||||
vars.insert("PYTHONUNBUFFERED".into(), "1".into());
|
||||
}
|
||||
vars.extend(config.env.iter().map(|(k, v)| (k.clone(), v.clone())));
|
||||
Ok(LaunchEnv { clear: !extras.include_system_env, vars })
|
||||
let mut env = LaunchEnv { clear: !extras.include_system_env, vars };
|
||||
// `npm.cmd` is found on the login-shell and Windows user PATH, then started by its
|
||||
// full path. The script it runs (`node …`) only sees this process's PATH, which
|
||||
// does not include that directory, so `node` is not recognized.
|
||||
let cwd = resolve_cwd(root, config.cwd.as_deref());
|
||||
if !env.clear && !env.vars.keys().any(|k| k.eq_ignore_ascii_case("PATH")) {
|
||||
let path = crate::wrap::search_path_in(config, &cwd);
|
||||
if let Some(text) = path.to_str().filter(|s| !s.is_empty()) {
|
||||
env.vars.insert("PATH".into(), text.to_owned());
|
||||
}
|
||||
}
|
||||
Ok(env)
|
||||
}
|
||||
|
||||
/// What a run in the project at `root` inherits with "Include system environment variables"
|
||||
@@ -1446,6 +1457,42 @@ mod tests {
|
||||
assert_eq!(binary.program, script);
|
||||
}
|
||||
|
||||
fn bare_config(env: BTreeMap<String, String>) -> RunConfig {
|
||||
RunConfig {
|
||||
id: "c".into(),
|
||||
name: "c".into(),
|
||||
kind: "npm".into(),
|
||||
command: "npm".into(),
|
||||
args: vec!["run".into(), "start".into()],
|
||||
cwd: None,
|
||||
env,
|
||||
detected: true,
|
||||
is_test: false,
|
||||
debug_adapter: None,
|
||||
allow_parallel: false,
|
||||
extras: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_run_inherits_the_path_used_to_resolve_its_program() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let config = bare_config(BTreeMap::new());
|
||||
let env = launch_env(dir.path(), &config).unwrap();
|
||||
let path = env.vars.get("PATH").expect("child PATH");
|
||||
let search = crate::wrap::search_path_in(&config, dir.path());
|
||||
assert_eq!(path, search.to_str().unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_explicit_path_override_is_kept() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let config = bare_config(BTreeMap::from([("Path".into(), r"C:\tools".into())]));
|
||||
let env = launch_env(dir.path(), &config).unwrap();
|
||||
assert_eq!(env.vars.get("Path").map(String::as_str), Some(r"C:\tools"));
|
||||
assert_eq!(env.vars.keys().filter(|k| k.eq_ignore_ascii_case("PATH")).count(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shell_lines_use_cmd_verbatim_on_windows() {
|
||||
let line = r#"(if not exist "C:\T\openidea-run" mkdir "C:\T\openidea-run") && "C:\Program Files\rustc.exe" -o "C:\T\openidea-run\hi.exe" hi.rs"#;
|
||||
|
||||
@@ -380,27 +380,59 @@ fn a_root_build_disables_the_nested_scan() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn spring_boot_applications_need_the_plugin_and_a_main() {
|
||||
fn spring_boot_applications_need_spring_boot_and_a_main() {
|
||||
let main =
|
||||
"package demo;\n@SpringBootApplication\npublic class App {\n public static void main(String[] args) {}\n}\n";
|
||||
// A library using Spring Boot without the plugin, a configuration class without `main`,
|
||||
// the annotation in a comment, a parent POM.
|
||||
// A module without Spring Boot in its build, a configuration class without `main`, the
|
||||
// annotation in a comment, a parent POM.
|
||||
let dir = project(&[
|
||||
("lib/pom.xml", "<project><dependencies>spring-boot-starter</dependencies></project>"),
|
||||
("lib/src/main/java/demo/App.java", main),
|
||||
("plain/pom.xml", "<project><dependencies>commons-lang3</dependencies></project>"),
|
||||
("plain/src/main/java/demo/App.java", main),
|
||||
("svc/pom.xml", BOOT_POM),
|
||||
("svc/src/main/java/demo/Config.java", "package demo;\n@SpringBootApplication\npublic class Config {}\n"),
|
||||
(
|
||||
"svc/src/main/java/demo/Old.java",
|
||||
"package demo;\n// @SpringBootApplication\nclass Old { public static void main(String[] a) {} }\n",
|
||||
),
|
||||
("gr/build.gradle", "dependencies { implementation 'org.springframework.boot:spring-boot-starter' }\n"),
|
||||
("gr/build.gradle", "dependencies { implementation 'com.google.guava:guava:33.0.0-jre' }\n"),
|
||||
("gr/src/main/java/demo/App.java", main),
|
||||
]);
|
||||
let c = detect(dir.path());
|
||||
assert!(!c.iter().any(|c| c.kind == "spring-boot"), "{:?}", ids(&c));
|
||||
}
|
||||
|
||||
/// Spring Boot on the classpath is enough, as for IntelliJ IDEA: a module depending on a
|
||||
/// starter (directly or through its parent POM) without the packaging plugin, and Gradle's
|
||||
/// dependency on `org.springframework.boot:…`.
|
||||
#[test]
|
||||
fn spring_boot_applications_without_the_plugin() {
|
||||
let main =
|
||||
"package demo;\n@SpringBootApplication\npublic class App {\n public static void main(String[] args) {}\n}\n";
|
||||
let dir = project(&[
|
||||
(
|
||||
"lib/pom.xml",
|
||||
"<project><dependencies><dependency><groupId>org.springframework.boot</groupId>\
|
||||
<artifactId>spring-boot-starter-web</artifactId></dependency></dependencies></project>",
|
||||
),
|
||||
("lib/src/main/java/demo/App.java", main),
|
||||
("gr/build.gradle", "dependencies { implementation 'org.springframework.boot:spring-boot-starter' }\n"),
|
||||
("gr/src/main/java/demo/App.java", main),
|
||||
]);
|
||||
let c = detect(dir.path());
|
||||
assert_eq!(find(&c, "application:lib:demo.App").kind, "spring-boot");
|
||||
assert_eq!(find(&c, "application:gr:demo.App").kind, "spring-boot");
|
||||
|
||||
let parent = "<project><packaging>pom</packaging><modules><module>job</module></modules>\
|
||||
<parent><groupId>org.springframework.boot</groupId>\
|
||||
<artifactId>spring-boot-starter-parent</artifactId></parent></project>";
|
||||
let dir = project(&[
|
||||
("pom.xml", parent),
|
||||
("job/pom.xml", "<project><artifactId>job</artifactId></project>"),
|
||||
("job/src/main/java/demo/App.java", main),
|
||||
]);
|
||||
assert_eq!(find(&detect(dir.path()), "application:job:demo.App").kind, "spring-boot");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn spring_boot_modules_inherit_the_plugin_from_their_parent_build() {
|
||||
let main = |pkg: &str, ann: &str, cls: &str| {
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
use crate::editorconfig::{EditorConfig, EditorConfigProps};
|
||||
use crate::file_defaults::FileDefaults;
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::event::NotifyLevel;
|
||||
use ide_core::{ChangeSet, DocId, IdeError, IdeEvent, IdeResult, LanguageId, SharedSink, TextEdit};
|
||||
use ide_text::{AppliedChange, ByteEdit, Document, LineEnding};
|
||||
use parking_lot::{Mutex, ReentrantMutex, RwLock};
|
||||
@@ -1138,6 +1137,24 @@ impl Documents {
|
||||
})
|
||||
}
|
||||
|
||||
/// Load Changes from Disk: drops the buffer's unsaved changes and reads its file again in
|
||||
/// the buffer's encoding, after the file changed on disk (`IdeEvent::DocDiskConflict`).
|
||||
pub fn discard_and_reload(&self, doc: DocId) -> IdeResult<()> {
|
||||
self.with_doc(doc, |st| {
|
||||
if st.uri.is_some() || st.binary {
|
||||
return Err(IdeError::invalid("only a file's text can be reloaded from disk"));
|
||||
}
|
||||
let loaded = Self::load_as(&st.path, &st.encoding, st.native_to_ascii)?;
|
||||
st.has_bom = loaded.has_bom;
|
||||
st.disk_mtime = loaded.mtime_ms;
|
||||
st.disk_len = disk_len(&st.path);
|
||||
st.disk_conflict = false;
|
||||
self.replace_locked(doc, st, &loaded.text)?;
|
||||
self.set_dirty(doc, st, false);
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
/// The URI of a virtual document, or `None` for a file-backed one.
|
||||
pub fn virtual_uri(&self, doc: DocId) -> IdeResult<Option<String>> {
|
||||
self.with_doc(doc, |st| Ok(st.uri.clone()))
|
||||
@@ -1250,7 +1267,7 @@ impl Documents {
|
||||
}
|
||||
|
||||
/// Re-reads from disk after an external change. Clean documents reload
|
||||
/// silently; dirty ones are left alone and reported via `IdeEvent::Notify`.
|
||||
/// silently; dirty ones are left alone and reported via `IdeEvent::DocDiskConflict`.
|
||||
/// Changes matching our own last save are ignored.
|
||||
pub fn on_disk_changed(&self, paths: &[PathBuf]) {
|
||||
self.reload_from_disk(paths, false, false);
|
||||
@@ -1289,16 +1306,7 @@ impl Documents {
|
||||
st.disk_mtime = mtime;
|
||||
st.disk_len = meta.len();
|
||||
st.disk_conflict = true;
|
||||
let name = st.path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
|
||||
self.sink.emit(IdeEvent::Notify {
|
||||
level: NotifyLevel::Warning,
|
||||
title: format!("{name} changed on disk"),
|
||||
body: Some(format!(
|
||||
"{} was modified externally but has unsaved changes in the editor. \
|
||||
Saving explicitly will overwrite the external changes; autosave leaves the file alone.",
|
||||
st.path.display()
|
||||
)),
|
||||
});
|
||||
self.sink.emit(IdeEvent::DocDiskConflict { doc: id, path: st.path.to_string_lossy().into_owned() });
|
||||
return Ok(());
|
||||
}
|
||||
let loaded = if force_clean {
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::event::NotifyLevel;
|
||||
use ide_core::{ChangeSet, DocId, IdeEvent, LanguageId, Pos, Range, SharedSink, TextChange, TextEdit};
|
||||
use ide_text::{AppliedChange, LineEnding};
|
||||
use ide_workspace::documents::DocumentObserver;
|
||||
@@ -565,15 +564,31 @@ fn external_changes() {
|
||||
fs::write(&path, "something else\n").unwrap();
|
||||
f.docs.on_disk_changed(std::slice::from_ref(&path));
|
||||
assert_eq!(f.docs.snapshot(id).unwrap().text, "// alpha\nBETA\ngamma\n");
|
||||
let warnings =
|
||||
f.events.lock().iter().filter(|e| matches!(e, IdeEvent::Notify { level: NotifyLevel::Warning, .. })).count();
|
||||
let warnings = f
|
||||
.events
|
||||
.lock()
|
||||
.iter()
|
||||
.filter(|e| matches!(e, IdeEvent::DocDiskConflict { path: p, .. } if *p == path.to_string_lossy()))
|
||||
.count();
|
||||
assert_eq!(warnings, 1);
|
||||
// The same disk state is reported only once.
|
||||
f.docs.on_disk_changed(std::slice::from_ref(&path));
|
||||
let warnings =
|
||||
f.events.lock().iter().filter(|e| matches!(e, IdeEvent::Notify { level: NotifyLevel::Warning, .. })).count();
|
||||
let warnings = f
|
||||
.events
|
||||
.lock()
|
||||
.iter()
|
||||
.filter(|e| matches!(e, IdeEvent::DocDiskConflict { path: p, .. } if *p == path.to_string_lossy()))
|
||||
.count();
|
||||
assert_eq!(warnings, 1);
|
||||
|
||||
// Load Changes from Disk drops the buffer's changes; autosave writes again afterwards.
|
||||
f.docs.discard_and_reload(id).unwrap();
|
||||
let reloaded = f.docs.snapshot(id).unwrap();
|
||||
assert_eq!((reloaded.text.as_str(), reloaded.dirty), ("something else\n", false));
|
||||
f.docs.edit(id, reloaded.version, change(0, 0, "# ")).unwrap();
|
||||
assert!(f.docs.autosave(id).unwrap());
|
||||
assert_eq!(fs::read_to_string(&path).unwrap(), "# something else\n");
|
||||
|
||||
// Unknown paths are ignored.
|
||||
f.docs.on_disk_changed(&[f.root.join("other.txt")]);
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -43,7 +43,7 @@ It reads repository state (status, diffs, blame, log) in-process, and runs the `
|
||||
- When creating a project, check **Create Git repository** in the New Project dialog.
|
||||
- **Git › Create Git Repository…** runs `git init` in a folder you pick (the project root by default) and registers the new repository right away; a repository created in the terminal is picked up the same way.
|
||||
|
||||
OpenIDEA finds the repository that contains the project and nested repositories up to four levels deep (skipping folders such as `node_modules`, `target` and `build`). Status, commit, fetch and update cover all of them; branch and log actions work on the selected repository. Submodules show as nested repositories, without submodule commands.
|
||||
OpenIDEA finds the repository that contains the project and nested repositories up to four levels deep (skipping folders such as `node_modules`, `target` and `build`). Status, commit, fetch and update cover all of them; branch operations from the branches popup cover all of them too (see [Branches](#branches)); log actions work on the selected repository. Submodules show as nested repositories, without submodule commands.
|
||||
|
||||
## Commit changes
|
||||
|
||||
@@ -143,7 +143,7 @@ Select a branch (`→` or `Enter`) for its actions:
|
||||
|
||||
If local changes block a checkout, you can choose **Smart Checkout** (stash, check out, unstash), **Force Checkout** or **Don't Checkout**. A deleted branch can be brought back with **Restore** in the notification.
|
||||
|
||||
With several repositories, the popup shows branches common to all of them, plus a submenu per repository.
|
||||
With several repositories, the popup shows branches common to all of them, plus a submenu per repository; an operation on a common branch (Checkout, Checkout and Rebase, Rebase, Merge, Update, Rename, Delete…) runs in every repository, and if it fails in one of them, OpenIDEA offers to roll back the others. When the repositories are on different branches, the popup says **Branches have diverged** and still lists the common branches, so checking one out brings them back in step. Turn off **Execute branch operations on all repositories** in the Git settings to list and act on the selected repository only.
|
||||
|
||||
## Sync with remotes
|
||||
|
||||
@@ -178,6 +178,7 @@ The **Log** tab of the Git tool window shows the commit graph.
|
||||
- **Graph Options**: sort by date, topologically or incoming first; first parent only; no merges.
|
||||
- **View Options**: reference display, details pane, and columns (**Author**, **Date**, **Hash**, **Signature**, **GitHub Commit Checks**).
|
||||
- The branches pane on the left filters the log by branch and has branch actions. Select several local branches and choose **Update Selected** to fast-forward each to its tracked branch, fetching each remote once; one notification lists the branches that were updated and those that could not be fast-forwarded or have no tracked branch.
|
||||
- With several repositories, the branches pane lists each branch once; a branch that only some repositories have shows their names after it in grey, and its actions run in those repositories. **Group by Repository** in the pane's toolbar shows one subtree per repository instead.
|
||||
- The details pane shows the changed files, the commit message, who committed it, which branches contain it and its signature.
|
||||
|
||||
Right-click a commit for **Copy Revision Number** (`⌥⇧⌘C` / `Ctrl+Alt+Shift+C`), **Create Patch…**, **Cherry-Pick**, **Checkout Revision**, **Browse Repository at Revision**, **Compare with Local**, **Reset Current Branch to Here…**, **Revert Commit**, **Undo Commit…**, **New Branch…**, **New Tag…**, **View in Browser** and more. With two commits selected, **Compare Versions** diffs them.
|
||||
@@ -238,16 +239,16 @@ Retention is set in the **Local History** section of **Settings › Appearance &
|
||||
|
||||
**Settings › Version Control** has these pages:
|
||||
|
||||
| Page | Main options |
|
||||
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| **Commit** | Non-modal commit interface, clearing the message after commit, message inspections (blank line after subject, subject and body length, right margin), default commit checks. |
|
||||
| **Confirmation** | What to do when files are created or deleted, **Show options before Update**, confirm before dropping commits, highlight modified folders in the Project view, history row limit. |
|
||||
| **Directory Mappings** | The detected repositories (read-only). |
|
||||
| **Issue Navigation** | Regex patterns that turn issue IDs in commit messages into links (presets for JIRA, YouTrack and GitHub). |
|
||||
| **Log** | Reference and time display, visible columns. |
|
||||
| **Shelf** | Remove applied files from the shelf. |
|
||||
| **Git** | Git executable, inline blame, commit warnings, sign-off default, push options and protected branches, update method (merge or rebase), incoming-commit checks, saved passwords, combining stash and shelf. |
|
||||
| **GitHub** | See [GitHub](/en/guide/github). |
|
||||
| Page | Main options |
|
||||
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| **Commit** | Non-modal commit interface, clearing the message after commit, message inspections (blank line after subject, subject and body length, right margin), default commit checks. |
|
||||
| **Confirmation** | What to do when files are created or deleted, **Show options before Update**, confirm before dropping commits, highlight modified folders in the Project view, history row limit. |
|
||||
| **Directory Mappings** | The detected repositories (read-only). |
|
||||
| **Issue Navigation** | Regex patterns that turn issue IDs in commit messages into links (presets for JIRA, YouTrack and GitHub). |
|
||||
| **Log** | Reference and time display, visible columns. |
|
||||
| **Shelf** | Remove applied files from the shelf. |
|
||||
| **Git** | Git executable, inline blame, commit warnings, sign-off default, push options and protected branches, update method (merge or rebase), incoming-commit checks, saved passwords, combining stash and shelf, branch operations on all repositories. |
|
||||
| **GitHub** | See [GitHub](/en/guide/github). |
|
||||
|
||||
## Not supported
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -43,7 +43,7 @@ OpenIDEA 内置 Git 支持,Git 也是它唯一支持的版本控制系统。
|
||||
- 新建项目时,在新建项目对话框中勾选 **创建 Git 仓库**。
|
||||
- **Git › 创建 Git 仓库…** 会在你选择的目录(默认是项目根目录)里执行 `git init`,并立即注册这个新仓库;在终端里创建的仓库同样会被识别。
|
||||
|
||||
OpenIDEA 会找到包含项目的仓库,以及向下最多四层的嵌套仓库(跳过 `node_modules`、`target`、`build` 等目录)。状态、提交、获取和更新覆盖所有仓库;分支和日志操作针对所选仓库。子模块显示为嵌套仓库,但没有子模块相关命令。
|
||||
OpenIDEA 会找到包含项目的仓库,以及向下最多四层的嵌套仓库(跳过 `node_modules`、`target`、`build` 等目录)。状态、提交、获取和更新覆盖所有仓库;分支弹窗中的分支操作同样覆盖所有仓库(见[分支](#分支));日志操作针对所选仓库。子模块显示为嵌套仓库,但没有子模块相关命令。
|
||||
|
||||
## 提交更改
|
||||
|
||||
@@ -141,7 +141,7 @@ OpenIDEA 会找到包含项目的仓库,以及向下最多四层的嵌套仓
|
||||
|
||||
如果本地更改阻止签出,可以选择 **智能签出**(贮藏、签出、再恢复)、**强制签出** 或 **不签出**。删除的分支可以通过通知中的 **恢复** 找回。
|
||||
|
||||
有多个仓库时,弹窗会显示所有仓库共有的分支,以及每个仓库各自的子菜单。
|
||||
有多个仓库时,弹窗会显示所有仓库共有的分支,以及每个仓库各自的子菜单;对公共分支的操作(签出、签出并变基、变基、合并、更新、重命名、删除等)会在每个仓库中执行,如果在某个仓库失败,OpenIDEA 会提议回滚其他仓库。各仓库处于不同分支时,弹窗会提示**分支已分叉**,但仍列出公共分支,检出其中一个即可让各仓库回到同一分支。在 Git 设置中关闭**在所有仓库执行分支操作**后,弹窗只列出并操作所选仓库。
|
||||
|
||||
## 与远程同步
|
||||
|
||||
@@ -176,6 +176,7 @@ Git 工具窗口的 **日志** 标签页显示提交图。
|
||||
- **图形选项**:按日期、拓扑或传入优先排序;仅第一父提交;不显示合并提交。
|
||||
- **视图选项**:引用显示方式、详情面板,以及列(**作者**、**日期**、**哈希**、**签名**、**GitHub 提交检查**)。
|
||||
- 左侧的分支面板可以按分支过滤日志,并提供分支操作。选中多个本地分支后选择 **Update Selected**,会把每个分支快进到它的跟踪分支,每个远程只 fetch 一次;结果汇总在一条通知里,列出已更新的分支,以及因不能快进或没有跟踪分支而未更新的分支。
|
||||
- 有多个仓库时,分支面板中每个分支只列一次;只存在于部分仓库的分支,后面会以灰字列出这些仓库,对它的操作会在这些仓库中执行。点击面板工具栏中的**按仓库分组**,可改为每个仓库一棵子树。
|
||||
- 详情面板显示变更文件、提交消息、提交者、包含该提交的分支以及签名。
|
||||
|
||||
右键提交可以选择 **复制修订号**(`⌥⇧⌘C` / `Ctrl+Alt+Shift+C`)、**创建补丁…**、**拣选**、**签出修订**、**浏览此修订版本的仓库**、**与本地比较**、**将当前分支重置到此处…**、**还原提交**、**撤消提交…**、**新建分支…**、**新建标签…**、**在浏览器中查看** 等。选中两个提交时,**比较版本** 会比较它们。
|
||||
@@ -236,16 +237,16 @@ Git 工具窗口的 **日志** 标签页显示提交图。
|
||||
|
||||
**设置 › 版本控制** 包含以下页面:
|
||||
|
||||
| 页面 | 主要选项 |
|
||||
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| **提交** | 非模态提交界面、提交后清空消息、提交消息检查(主题与正文之间空行、主题和正文长度、右边距)、默认提交检查。 |
|
||||
| **确认** | 新建或删除文件时的处理方式、**更新前显示选项**、丢弃提交前确认、在项目视图中高亮包含修改的目录、历史记录行数上限。 |
|
||||
| **目录映射** | 检测到的仓库(只读)。 |
|
||||
| **问题导航** | 把提交消息中的问题编号变成链接的正则规则(内置 JIRA、YouTrack 和 GitHub 预设)。 |
|
||||
| **日志** | 引用和时间的显示方式、显示哪些列。 |
|
||||
| **搁置** | 应用后从搁置中移除文件。 |
|
||||
| **Git** | Git 可执行文件、内联 Blame、提交警告、默认签署、推送选项和受保护分支、更新方式(合并或变基)、传入提交检查、已保存的密码、合并显示贮藏和搁置。 |
|
||||
| **GitHub** | 见 [GitHub](/zh/guide/github)。 |
|
||||
| 页面 | 主要选项 |
|
||||
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| **提交** | 非模态提交界面、提交后清空消息、提交消息检查(主题与正文之间空行、主题和正文长度、右边距)、默认提交检查。 |
|
||||
| **确认** | 新建或删除文件时的处理方式、**更新前显示选项**、丢弃提交前确认、在项目视图中高亮包含修改的目录、历史记录行数上限。 |
|
||||
| **目录映射** | 检测到的仓库(只读)。 |
|
||||
| **问题导航** | 把提交消息中的问题编号变成链接的正则规则(内置 JIRA、YouTrack 和 GitHub 预设)。 |
|
||||
| **日志** | 引用和时间的显示方式、显示哪些列。 |
|
||||
| **搁置** | 应用后从搁置中移除文件。 |
|
||||
| **Git** | Git 可执行文件、内联 Blame、提交警告、默认签署、推送选项和受保护分支、更新方式(合并或变基)、传入提交检查、已保存的密码、合并显示贮藏和搁置、在所有仓库执行分支操作。 |
|
||||
| **GitHub** | 见 [GitHub](/zh/guide/github)。 |
|
||||
|
||||
## 暂不支持
|
||||
|
||||
|
||||
@@ -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,68 @@
|
||||
import type { AttachableProcess } from "../src/bindings";
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("keeps the process columns and selection visible in a short window", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 460, height: 440 });
|
||||
await stubDesktop(page);
|
||||
const processes: AttachableProcess[] = [
|
||||
{
|
||||
pid: 4100,
|
||||
name: "java",
|
||||
commandLine: "java -jar /sample/invoice-service.jar",
|
||||
kind: "java",
|
||||
adapter: "java",
|
||||
host: "localhost",
|
||||
port: 5005,
|
||||
},
|
||||
...Array.from({ length: 24 }, (_, i): AttachableProcess => ({
|
||||
pid: 4201 + i,
|
||||
name: `invoice-worker-${i + 1}`,
|
||||
commandLine: `node /sample/services/long-package-name/invoice-worker.js --stage settlement-runner-${i + 1}`,
|
||||
kind: "node",
|
||||
adapter: "js-debug",
|
||||
host: "localhost",
|
||||
port: 9230 + i,
|
||||
})),
|
||||
];
|
||||
await page.evaluate(async (processes) => {
|
||||
window.__ipc.handlers.debug_attachable_processes = () => processes;
|
||||
const actions = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ actions);
|
||||
await executeAction("debug.attachToProcess");
|
||||
}, processes);
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Attach to process", exact: true });
|
||||
const filter = dialog.getByRole("textbox", { name: "Filter processes" });
|
||||
await expect(filter).toBeFocused();
|
||||
const table = dialog.getByRole("grid", { name: "Processes" });
|
||||
const pid = table.getByRole("columnheader", { name: "PID", exact: true });
|
||||
await expect(pid).toBeInViewport({ ratio: 1 });
|
||||
await expect(table.getByRole("columnheader", { name: "Command line" })).toBeInViewport({ ratio: 1 });
|
||||
|
||||
await filter.fill("settlement-runner");
|
||||
for (let i = 1; i < 24; i++) await page.keyboard.press("ArrowDown");
|
||||
const last = table.getByRole("row", { name: /^invoice-worker-24 / });
|
||||
await expect(last).toHaveAttribute("aria-selected", "true");
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(pid).toBeInViewport({ ratio: 1 });
|
||||
await expect(last.getByText(":9253", { exact: true })).toBeVisible();
|
||||
await expect(last.getByTitle("localhost:9253", { exact: true })).toBeVisible();
|
||||
const lastPid = last.getByRole("gridcell", { name: "4224", exact: true });
|
||||
expect((await lastPid.boundingBox())!.x).toBeCloseTo((await pid.boundingBox())!.x, 0);
|
||||
const scrollArea = table.getByRole("rowgroup").last();
|
||||
expect(await scrollArea.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
expect(await scrollArea.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await expect(filter).toBeFocused();
|
||||
await expect(filter).toBeInViewport({ ratio: 1 });
|
||||
for (const name of ["Refresh", "Attach", "Cancel"]) {
|
||||
await expect(dialog.getByRole("button", { name, exact: true })).toBeInViewport({ ratio: 1 });
|
||||
}
|
||||
|
||||
await page.setViewportSize({ width: 1040, height: 680 });
|
||||
await expect(last.getByText("localhost:9253", { exact: true })).toBeVisible();
|
||||
await filter.fill("unmatched-process");
|
||||
await expect(dialog.getByText("No attachable processes match the filter.")).toBeVisible();
|
||||
await expect(dialog.getByRole("button", { name: "Attach", exact: true })).toBeDisabled();
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await expect(dialog).toBeHidden();
|
||||
});
|
||||
@@ -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,51 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("the conflict actions stay visible beside or below the file list as the dialog resizes", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.evaluate(async () => {
|
||||
const storeModule = "/src/features/vcs/store.ts";
|
||||
const dialogModule = "/src/features/vcs/conflictsUi.tsx";
|
||||
const { useVcs } = await import(/* @vite-ignore */ storeModule);
|
||||
const { showConflictsDialog } = await import(/* @vite-ignore */ dialogModule);
|
||||
const root = "/dev/acme-api";
|
||||
useVcs.setState({
|
||||
root,
|
||||
status: Array.from({ length: 24 }, (_, index) => {
|
||||
const relPath = `services/payment-configuration/environments/env-${index + 1}.txt`;
|
||||
return { path: `${root}/${relPath}`, relPath, staged: null, unstaged: "conflicted", renamedFrom: null };
|
||||
}),
|
||||
});
|
||||
showConflictsDialog();
|
||||
});
|
||||
const dialog = page.getByRole("dialog", { name: "Conflicts", exact: true });
|
||||
const list = dialog.getByRole("listbox", { name: "Conflicted files" });
|
||||
const yours = dialog.getByRole("button", { name: "Accept Yours", exact: true });
|
||||
await expect(list).toBeFocused();
|
||||
const listBox = (await list.boundingBox())!;
|
||||
const first = (await yours.boundingBox())!;
|
||||
expect(first.x).toBeGreaterThan(listBox.x + listBox.width);
|
||||
expect(first.y).toBeLessThan(listBox.y + listBox.height / 2);
|
||||
|
||||
const grip = (await dialog.getByRole("separator", { name: "Resize", exact: true }).boundingBox())!;
|
||||
await page.mouse.move(grip.x + grip.width / 2, grip.y + grip.height / 2);
|
||||
await page.mouse.down();
|
||||
await page.mouse.move(grip.x + 36, grip.y + 68, { steps: 5 });
|
||||
await page.mouse.up();
|
||||
await expect.poll(async () => (await list.boundingBox())!.height).toBeGreaterThan(listBox.height + 40);
|
||||
|
||||
await page.setViewportSize({ width: 430, height: 530 });
|
||||
await expect(yours).toBeInViewport({ ratio: 1 });
|
||||
expect((await yours.boundingBox())!.y).toBeGreaterThan(
|
||||
(await list.boundingBox())!.y + (await list.boundingBox())!.height,
|
||||
);
|
||||
for (const name of ["Accept Theirs", "Merge…"])
|
||||
await expect(dialog.getByRole("button", { name, exact: true })).toBeInViewport({ ratio: 1 });
|
||||
await expect(dialog.locator("[data-dialog-footer]").getByRole("button", { name: "Close" })).toBeInViewport({
|
||||
ratio: 1,
|
||||
});
|
||||
await list.press("End");
|
||||
await expect(list.getByRole("option", { selected: true })).toContainText("env-24.txt");
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(dialog).toBeHidden();
|
||||
});
|
||||
@@ -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();
|
||||
});
|
||||
@@ -55,6 +55,39 @@ test("⌘F opens the find bar and highlights matches; Escape returns to the edit
|
||||
await expect(editor.locator(".cm-content")).toBeFocused();
|
||||
});
|
||||
|
||||
test("Go to Line keeps its label beside the selected coordinates and returns focus to the editor", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const editor = await openFromTree(page, "build.gradle.kts");
|
||||
const content = editor.locator(".cm-content");
|
||||
await content.focus();
|
||||
await page.keyboard.press("Meta+l");
|
||||
const dialog = page.getByRole("dialog", { name: "Go to Line:Column", exact: true });
|
||||
const coordinates = dialog.getByRole("textbox", { name: "Line and column", exact: true });
|
||||
await expect(coordinates).toBeFocused();
|
||||
await expect(coordinates).toHaveValue("1:1");
|
||||
expect(await coordinates.evaluate((el: HTMLInputElement) => [el.selectionStart, el.selectionEnd])).toEqual([0, 3]);
|
||||
|
||||
await page.setViewportSize({ width: 360, height: 500 });
|
||||
const label = dialog.getByText("Line and column", { exact: true });
|
||||
await expect(label).toBeVisible();
|
||||
const text = (await label.boundingBox())!;
|
||||
const field = (await coordinates.boundingBox())!;
|
||||
expect(text.x + text.width).toBeLessThan(field.x);
|
||||
expect(Math.abs(text.y + text.height / 2 - field.y - field.height / 2)).toBeLessThan(2);
|
||||
await expect(coordinates).toHaveCSS("font-size", await label.evaluate((el) => getComputedStyle(el).fontSize));
|
||||
|
||||
await coordinates.fill("0:2");
|
||||
await expect(coordinates).toHaveAttribute("aria-invalid", "true");
|
||||
await expect(dialog.getByRole("button", { name: "OK", exact: true })).toBeDisabled();
|
||||
await coordinates.fill("6:8");
|
||||
await coordinates.press("Enter");
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect(content).toBeFocused();
|
||||
await page.setViewportSize({ width: 960, height: 600 });
|
||||
await expect(page.getByRole("button", { name: "6:8", exact: true })).toBeVisible();
|
||||
});
|
||||
|
||||
test("each file keeps its own find bar, query and caret", async ({ workbench: page }) => {
|
||||
const find = page.getByRole("textbox", { name: "Find" });
|
||||
const caret = page.getByRole("button", { name: /^\d+:\d+/ });
|
||||
@@ -373,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");
|
||||
@@ -591,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,65 @@
|
||||
import type { ExtractInterfaceInfo } from "../src/bindings";
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
const info: ExtractInterfaceInfo = {
|
||||
className: "InvoiceService",
|
||||
packages: [
|
||||
{ displayName: "com.example.billing", path: "/dev/acme-api", isParentOfSelectedFile: true },
|
||||
{ displayName: "com.example.billing.api", path: "/dev/acme-api/api" },
|
||||
].map((entry) => JSON.stringify(entry)),
|
||||
members: Array.from({ length: 24 }, (_, i) => ({
|
||||
name: `prepareInvoiceForInternationalSettlement${i + 1}`,
|
||||
parameters: ["BigDecimal", "Map<String, BigDecimal>", "LocalDate", "boolean"],
|
||||
typeName: "SettlementInvoice",
|
||||
handleIdentifier: `method-${i + 1}`,
|
||||
})),
|
||||
};
|
||||
|
||||
test("keeps the interface fields, members and actions usable in a short window", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 470, height: 410 });
|
||||
await page.evaluate(async () => {
|
||||
const workbench = "/src/workbench/contributions.ts";
|
||||
const { editorService } = await import(/* @vite-ignore */ workbench);
|
||||
await editorService().openFile("/dev/acme-api/InvoiceService.java", { focus: true });
|
||||
});
|
||||
const editor = page.locator(".cm-editor .cm-content");
|
||||
await expect(editor).toBeVisible();
|
||||
await stubDesktop(page);
|
||||
await editor.focus();
|
||||
await page.evaluate(async (info) => {
|
||||
window.__ipc.handlers.lsp_extract_interface_info = () => info;
|
||||
const actions = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ actions);
|
||||
await executeAction("refactor.extractInterface");
|
||||
}, info);
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Extract Interface" });
|
||||
const table = dialog.getByRole("table", { name: "Members to Form Interface" });
|
||||
await expect(table.getByRole("row")).toHaveCount(25);
|
||||
const source = dialog.getByRole("textbox", { name: "Extract interface from:", exact: true });
|
||||
const name = dialog.getByRole("textbox", { name: "Interface name:", exact: true });
|
||||
await expect(source).toHaveAttribute("readonly", "");
|
||||
await expect(source).toHaveValue("InvoiceService");
|
||||
await expect(name).toBeFocused();
|
||||
await expect(source).toBeInViewport({ ratio: 1 });
|
||||
await name.fill("SettlementInvoicing");
|
||||
|
||||
const body = dialog.locator("[data-dialog-body]");
|
||||
const refactor = dialog.getByRole("button", { name: "Refactor", exact: true });
|
||||
await expect(refactor).toBeDisabled();
|
||||
const last = table.getByRole("checkbox", { name: /^prepareInvoiceForInternationalSettlement24\(/ });
|
||||
await last.scrollIntoViewIfNeeded();
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(table.getByRole("columnheader", { name: "Member" })).toBeInViewport({ ratio: 1 });
|
||||
await expect.poll(() => table.evaluate((el) => el.scrollTop)).toBeGreaterThan(100);
|
||||
expect(await table.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
expect(await body.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await last.check();
|
||||
await expect(refactor).toBeEnabled();
|
||||
expect(await body.evaluate((el) => el.scrollHeight - el.clientHeight)).toBeLessThanOrEqual(1);
|
||||
await expect(refactor).toBeInViewport({ ratio: 1 });
|
||||
await expect(dialog.getByRole("button", { name: "Preview", exact: true })).toBeInViewport({ ratio: 1 });
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect(editor).toBeFocused();
|
||||
});
|
||||
@@ -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,68 @@
|
||||
import type { Remote, RemoteEdit } from "../src/bindings";
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("keeps remote columns, actions and editing usable in a short window", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 450, height: 420 });
|
||||
await stubDesktop(page);
|
||||
const originalUrl = "https://git.example.test/engineering/international-settlement/replica-18.git";
|
||||
await page.evaluate(async (originalUrl) => {
|
||||
let remotes: Remote[] = Array.from({ length: 18 }, (_, i) => ({
|
||||
name: i === 0 ? "origin" : `mirror-${i + 1}`,
|
||||
url: i === 17 ? originalUrl : `https://git.example.test/project/repository-${i + 1}.git`,
|
||||
}));
|
||||
window.__ipc.handlers.vcs_remotes = () => remotes;
|
||||
window.__ipc.handlers.vcs_edit_remote = ({ edit }) => {
|
||||
const patch = edit as RemoteEdit;
|
||||
if (patch.op === "edit") {
|
||||
remotes = remotes.map((remote) =>
|
||||
remote.name === patch.name ? { name: patch.new_name, url: patch.url } : remote,
|
||||
);
|
||||
}
|
||||
return null;
|
||||
};
|
||||
window.__ipc.handlers.vcs_branches = () => [];
|
||||
const module = "/src/features/vcs/gitMenuDialogs.tsx";
|
||||
const { showManageRemotes } = await import(/* @vite-ignore */ module);
|
||||
showManageRemotes();
|
||||
}, originalUrl);
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Git Remotes", exact: true });
|
||||
await expect(dialog.getByText(originalUrl, { exact: true })).toBeVisible();
|
||||
const table = dialog.getByRole("grid", { name: "Remotes", exact: true });
|
||||
const name = table.getByRole("columnheader", { name: "Name", exact: true });
|
||||
const url = table.getByRole("columnheader", { name: "URL", exact: true });
|
||||
await expect(name).toBeInViewport({ ratio: 1 });
|
||||
await expect(url).toBeInViewport({ ratio: 1 });
|
||||
const first = table.getByRole("row", { name: /^origin / });
|
||||
const last = table.getByRole("row", { name: /^mirror-18 / });
|
||||
await first.click();
|
||||
await page.keyboard.press("End");
|
||||
await expect(last).toBeFocused();
|
||||
await expect(last).toHaveAttribute("aria-selected", "true");
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(url).toBeInViewport({ ratio: 1 });
|
||||
const cell = last.getByRole("gridcell", { name: originalUrl, exact: true });
|
||||
await expect(cell).toHaveAttribute("title", originalUrl);
|
||||
expect((await cell.boundingBox())!.x).toBeCloseTo((await url.boundingBox())!.x, 0);
|
||||
const scroller = table.locator("..");
|
||||
expect(await scroller.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
expect(await scroller.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await expect(dialog.getByRole("button", { name: "Add Remote…" })).toBeInViewport({ ratio: 1 });
|
||||
await expect(dialog.getByRole("button", { name: "OK", exact: true })).toBeInViewport({ ratio: 1 });
|
||||
|
||||
await page.keyboard.press("Enter");
|
||||
const edit = page.getByRole("dialog", { name: "Edit Remote", exact: true });
|
||||
const editName = edit.getByRole("textbox", { name: "Name", exact: true });
|
||||
const editUrl = edit.getByRole("textbox", { name: "URL", exact: true });
|
||||
await expect(editName).toHaveValue("mirror-18");
|
||||
await expect(editUrl).toHaveValue(originalUrl);
|
||||
expect((await editName.boundingBox())!.x).toBeCloseTo((await editUrl.boundingBox())!.x, 0);
|
||||
const nextUrl = "https://git.example.test/repository-18.git";
|
||||
await editUrl.fill(nextUrl);
|
||||
await edit.getByRole("button", { name: "OK", exact: true }).click();
|
||||
await expect(last).toContainText(nextUrl);
|
||||
await expect(last).toBeFocused();
|
||||
expect(await ipcCalls(page, "vcs_edit_remote")).toMatchObject([
|
||||
{ edit: { op: "edit", name: "mirror-18", new_name: "mirror-18", url: nextUrl } },
|
||||
]);
|
||||
});
|
||||
@@ -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,37 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("gutter icon previews align in narrow settings and the master switch keeps each choice", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await settings.getByRole("textbox", { name: "Search settings" }).fill("Color preview");
|
||||
await settings.getByRole("treeitem", { name: "Gutter Icons", exact: true }).click();
|
||||
await page.setViewportSize({ width: 520, height: 620 });
|
||||
|
||||
const list = settings.getByRole("list", { name: "Gutter Icons", exact: true });
|
||||
await expect(list.getByRole("listitem")).toHaveCount(5);
|
||||
await expect(list.locator("mark")).toHaveText(["Color", "preview"]);
|
||||
const layout = await list.getByRole("listitem").evaluateAll((rows) =>
|
||||
rows.map((row) => {
|
||||
const preview = row.firstElementChild!.getBoundingClientRect();
|
||||
const input = row.querySelector("input")!.getBoundingClientRect();
|
||||
return { x: input.x, previewRight: preview.right, overflow: row.scrollWidth - row.clientWidth };
|
||||
}),
|
||||
);
|
||||
for (const row of layout) {
|
||||
expect(row.previewRight).toBeLessThan(row.x);
|
||||
expect(row.x).toBeCloseTo(layout[0]!.x, 0);
|
||||
expect(row.overflow).toBeLessThanOrEqual(1);
|
||||
}
|
||||
|
||||
const master = settings.getByRole("checkbox", { name: "Show gutter icons", exact: true });
|
||||
const color = list.getByRole("checkbox", { name: "Color preview", exact: true });
|
||||
await color.uncheck();
|
||||
await master.uncheck();
|
||||
for (const option of await list.getByRole("checkbox").all()) await expect(option).toBeDisabled();
|
||||
await master.check();
|
||||
await expect(color).toBeEnabled();
|
||||
await expect(color).not.toBeChecked();
|
||||
await expect(list.getByRole("checkbox", { name: "Bookmarks", exact: true })).toBeChecked();
|
||||
});
|
||||
@@ -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();
|
||||
});
|
||||
@@ -0,0 +1,89 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("inspection results keep source context and actions visible as the dock narrows", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1100, height: 720 });
|
||||
const relative = "modules/settlement/reconciliation/QuarterlySettlementReconciliationCoordinator.ts";
|
||||
const path = `/dev/acme-api/${relative}`;
|
||||
const title = "The estimated settlement total ignores the currency conversion for pending merchant payments";
|
||||
const detail = "Check the calculation before saving the reconciliation report.";
|
||||
await page.evaluate(async (path) => {
|
||||
const backend = "/src/editor/core/backend.ts";
|
||||
(await import(/* @vite-ignore */ backend))
|
||||
.docBackend()
|
||||
.files.set(path, "const amount = 100;\nconst exchangeRate = 3;\nconst estimate = amount;\n");
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile(path);
|
||||
}, path);
|
||||
await expect(page.locator(".cm-content")).toContainText("estimate");
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ path, relative, title, detail }) => {
|
||||
window.__ipc.handlers.inspect_code = ({ onEvent }) => {
|
||||
window.__ipc.send(onEvent, { type: "started", total: 1 });
|
||||
window.__ipc.send(onEvent, {
|
||||
type: "file",
|
||||
done: 1,
|
||||
file: {
|
||||
path,
|
||||
relPath: relative,
|
||||
diagnostics: [
|
||||
{
|
||||
range: { start: { line: 2, col: 6 }, end: { line: 2, col: 14 } },
|
||||
severity: "warning",
|
||||
message: `${title}\n${detail}`,
|
||||
source: "lint",
|
||||
code: "pending-currency-conversion",
|
||||
},
|
||||
],
|
||||
},
|
||||
});
|
||||
window.__ipc.send(onEvent, {
|
||||
type: "done",
|
||||
summary: { files: 1, problems: 1, skipped: 0, failed: 0, cancelled: false, elapsedMs: 30 },
|
||||
});
|
||||
};
|
||||
const actions = "/src/platform/actions.ts";
|
||||
await (await import(/* @vite-ignore */ actions)).executeAction("analyze.inspectFile");
|
||||
},
|
||||
{ path, relative, title, detail },
|
||||
);
|
||||
|
||||
const tree = page.getByRole("tree", { name: "Inspection results" });
|
||||
const problem = tree.getByRole("treeitem").filter({ hasText: title });
|
||||
await problem.click({ position: { x: 95, y: 12 } });
|
||||
const jump = page.getByRole("button", { name: "Jump to Source" });
|
||||
const message = page.getByText(detail, { exact: false }).filter({ visible: true }).last();
|
||||
expect((await jump.boundingBox())!.y).toBeLessThan((await message.boundingBox())!.y);
|
||||
const details = page.getByRole("region", { name: "Inspection details" });
|
||||
const quickFixes = details.getByRole("button", { name: "Show Quick Fixes" });
|
||||
await expect(details.getByText(`${relative}:3:7`)).toBeVisible();
|
||||
const split = page.getByRole("separator", { name: "Resize inspection panes" });
|
||||
await expect(split).toHaveAttribute("aria-valuenow", "50");
|
||||
await split.focus();
|
||||
await page.keyboard.press("ArrowRight");
|
||||
await expect(split).not.toHaveAttribute("aria-valuenow", "50");
|
||||
|
||||
await page.setViewportSize({ width: 540, height: 680 });
|
||||
await expect(quickFixes).toBeInViewport({ ratio: 1 });
|
||||
await expect(jump).toBeInViewport({ ratio: 1 });
|
||||
const right = (await details.boundingBox())!;
|
||||
const jumpBounds = (await jump.boundingBox())!;
|
||||
expect(jumpBounds.x + jumpBounds.width).toBeLessThan(right.x + right.width);
|
||||
const file = tree.getByRole("treeitem").filter({ has: page.getByTitle(relative, { exact: true }) });
|
||||
const count = file.getByText("1", { exact: true });
|
||||
const fileBounds = (await file.boundingBox())!;
|
||||
const countBounds = (await count.boundingBox())!;
|
||||
expect(countBounds.x + countBounds.width).toBeLessThan(fileBounds.x + fileBounds.width);
|
||||
expect(await message.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
expect(await tree.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await jump.click();
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(async () => {
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
const cursor = (await import(/* @vite-ignore */ service)).editorService().activeCursor();
|
||||
return { path: cursor?.path, line: cursor?.line, col: cursor?.col };
|
||||
}),
|
||||
)
|
||||
.toEqual({ path, line: 2, col: 6 });
|
||||
});
|
||||
@@ -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,59 @@
|
||||
import { expect, openFromTree, test } from "./fixtures";
|
||||
|
||||
test("keyboard navigation reveals items in a short Git submenu", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 650, height: 390 });
|
||||
const editor = await openFromTree(page, "README.md");
|
||||
await editor.locator(".cm-content").click({ button: "right" });
|
||||
await page.getByRole("menuitem", { name: "Git", exact: true }).hover();
|
||||
const last = page.getByRole("menuitem", { name: "Clone…", exact: true });
|
||||
const popup = last.locator("xpath=ancestor::*[@data-popup][1]");
|
||||
const first = popup.locator('[role="menuitem"]:not([aria-disabled="true"])').first();
|
||||
await expect(popup).toHaveAttribute("data-positioned", "true");
|
||||
await expect(first).toBeFocused();
|
||||
expect(await popup.evaluate((el) => el.scrollHeight)).toBeGreaterThan(await popup.evaluate((el) => el.clientHeight));
|
||||
|
||||
await page.keyboard.press("End");
|
||||
await expect(last).toBeFocused();
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect.poll(() => popup.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
|
||||
const scroll = await popup.evaluate((el) => el.scrollTop);
|
||||
await popup.evaluate((el) => (el.scrollTop = 0));
|
||||
await page.keyboard.press("End");
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect.poll(() => popup.evaluate((el) => el.scrollTop)).toBe(scroll);
|
||||
|
||||
await page.keyboard.press("Home");
|
||||
await expect(first).toBeFocused();
|
||||
await expect(first).toBeInViewport({ ratio: 1 });
|
||||
await expect.poll(() => popup.evaluate((el) => el.scrollTop)).toBeLessThan(scroll);
|
||||
await page.keyboard.press("ArrowLeft");
|
||||
await expect(last).toBeHidden();
|
||||
await expect(page.getByRole("menuitem", { name: "Git", exact: true })).toBeFocused();
|
||||
});
|
||||
|
||||
test("shortcut ends align on a menu level with submenus", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 390, height: 480 });
|
||||
const chord = "Ctrl+Shift+Meta+K, Ctrl+Shift+Meta+B, Ctrl+Shift+Meta+M";
|
||||
await page.evaluate(async (chord) => {
|
||||
const path = "/src/ui/Menu.tsx";
|
||||
const { showContextMenu } = await import(/* @vite-ignore */ path);
|
||||
showContextMenu({ x: 80, y: 80 }, [
|
||||
{ label: "Open", shortcut: "Ctrl+O" },
|
||||
{ label: "Open Recent", shortcut: "Ctrl+Shift+O", submenu: [{ label: "Payments service" }] },
|
||||
{ label: "Open File in a New Window", shortcut: chord },
|
||||
]);
|
||||
}, chord);
|
||||
const menu = page.getByRole("menu", { name: "Context menu" });
|
||||
const first = menu.getByText("Ctrl+O", { exact: true });
|
||||
const second = menu.getByText("Ctrl+Shift+O", { exact: true });
|
||||
await expect(first).toBeVisible();
|
||||
await expect(second).toBeVisible();
|
||||
const a = (await first.boundingBox())!;
|
||||
const b = (await second.boundingBox())!;
|
||||
expect(a.x + a.width).toBeCloseTo(b.x + b.width, 0);
|
||||
const long = menu.getByText(chord, { exact: true });
|
||||
await expect(long).toHaveAttribute("title", chord);
|
||||
expect(await long.evaluate((el) => el.scrollWidth)).toBeGreaterThan(await long.evaluate((el) => el.clientWidth));
|
||||
await expect(menu.getByText("Open File in a New Window", { exact: true })).toBeInViewport({ ratio: 1 });
|
||||
});
|
||||
@@ -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();
|
||||
});
|
||||
@@ -1,4 +1,4 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test.use({ video: "on" });
|
||||
|
||||
@@ -100,3 +100,46 @@ test("uses the single project's type in the keyboard New popup", async ({ workbe
|
||||
page.getByRole("dialog", { name: "New File from Template" }).getByText("Go File", { exact: true }),
|
||||
).toBeVisible();
|
||||
});
|
||||
|
||||
test("names a file from a template and keeps keyboard kind selection visible in a short window", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const root = "/dev/acme-api";
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(() => {
|
||||
window.__ipc.handlers.fs_create_file = () => null;
|
||||
});
|
||||
await page.locator(`[data-project-path="${root}"]`).click();
|
||||
await page.keyboard.press("Meta+n");
|
||||
const menu = page.getByRole("dialog", { name: "New", exact: true });
|
||||
await menu.getByRole("textbox", { name: "Search for file type" }).fill("from template");
|
||||
await menu.getByText("From Template…", { exact: true }).click();
|
||||
const templates = page.getByRole("dialog", { name: "New File from Template" });
|
||||
const kotlin = templates.getByRole("option", { name: "Kotlin Class/File", exact: true });
|
||||
await kotlin.hover();
|
||||
await expect(kotlin).toHaveAttribute("aria-selected", "true");
|
||||
await page.keyboard.press("Enter");
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "New Kotlin Class/File", exact: true });
|
||||
const name = dialog.getByRole("textbox", { name: "Name", exact: true });
|
||||
const kinds = dialog.getByRole("listbox", { name: "Kind", exact: true });
|
||||
await expect(name).toBeFocused();
|
||||
await page.setViewportSize({ width: 430, height: 380 });
|
||||
const bounds = (await dialog.boundingBox())!;
|
||||
expect(Math.abs(bounds.y + bounds.height / 2 - 190)).toBeLessThan(12);
|
||||
await expect.poll(() => kinds.evaluate((el) => el.scrollHeight - el.clientHeight)).toBeGreaterThan(0);
|
||||
|
||||
await name.press("Enter");
|
||||
await expect(dialog.getByRole("alert")).toHaveText("Enter a name");
|
||||
await name.fill("OrderSummary");
|
||||
await name.press("ArrowUp");
|
||||
const last = kinds.getByRole("option", { name: "JUnit 5 Test", selected: true });
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(name).toBeFocused();
|
||||
for (let i = 0; i < 3; i++) await name.press("ArrowUp");
|
||||
await expect(kinds.getByRole("option", { name: "Data class", selected: true })).toBeVisible();
|
||||
await name.press("Enter");
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect.poll(() => ipcCalls(page, "fs_create_file")).toEqual([{ path: `${root}/OrderSummary.kt` }]);
|
||||
await expect(page.getByRole("tab", { name: "OrderSummary.kt" })).toHaveAttribute("aria-selected", "true");
|
||||
});
|
||||
@@ -37,6 +37,30 @@ test("type-ahead jumps to a matching node", async ({ workbench: page }) => {
|
||||
await expect(tree.locator('[role="treeitem"][aria-selected="true"]')).toHaveText("README.md");
|
||||
});
|
||||
|
||||
test("the file deletion form keeps its option and buttons visible in a narrow window", async ({ workbench: page }) => {
|
||||
const file = page.getByRole("treeitem", { name: "README.md", exact: true });
|
||||
await file.click({ button: "right" });
|
||||
await page.getByRole("menuitem", { name: /^Delete…/ }).click();
|
||||
const dialog = page.getByRole("dialog", { name: "Delete", exact: true });
|
||||
await expect(dialog).toBeVisible();
|
||||
await page.setViewportSize({ width: 430, height: 530 });
|
||||
await expect(dialog.locator("[data-dialog-titlebar]")).toContainText("Delete");
|
||||
await expect(dialog).toContainText("Delete 'README.md'?");
|
||||
await expect(dialog).toContainText("Items are moved to the Trash.");
|
||||
const search = dialog.getByRole("checkbox", { name: "Safe delete (with usage search)", exact: true });
|
||||
await expect(search).toBeChecked();
|
||||
await expect(dialog.getByRole("button", { name: "Delete", exact: true })).toBeFocused();
|
||||
await expect(dialog.getByRole("button", { name: "Cancel", exact: true })).toBeInViewport();
|
||||
const option = await search.boundingBox();
|
||||
const footer = await dialog.locator("[data-dialog-footer]").boundingBox();
|
||||
expect(option!.y + option!.height).toBeLessThan(footer!.y);
|
||||
await search.uncheck();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(dialog).toBeHidden();
|
||||
await page.setViewportSize({ width: 1100, height: 730 });
|
||||
await expect(file).toBeVisible();
|
||||
});
|
||||
|
||||
test("Git ignore submenu offers shared and local destinations for files and folders", async ({ workbench: page }) => {
|
||||
for (const name of ["README.md", "src"]) {
|
||||
await page.getByRole("treeitem", { name, exact: true }).click({ button: "right" });
|
||||
@@ -110,3 +134,29 @@ test("a real mouse drag still shows the drag label until release", async ({ work
|
||||
await page.mouse.up();
|
||||
await expect(dragLabel).toHaveCount(0);
|
||||
});
|
||||
|
||||
test("Copy aligns the file fields and keeps the open-in-editor option in the footer", async ({ workbench: page }) => {
|
||||
await page.getByRole("treeitem", { name: "README.md", exact: true }).click();
|
||||
await page.keyboard.press("F5");
|
||||
const dialog = page.getByRole("dialog", { name: "Copy", exact: true });
|
||||
const name = dialog.getByRole("textbox", { name: "New name" });
|
||||
const target = dialog.getByRole("textbox", { name: "Target directory" });
|
||||
const openCopy = dialog.getByRole("checkbox", { name: "Open copy in editor" });
|
||||
await expect(name).toBeFocused();
|
||||
expect(await name.evaluate((el: HTMLInputElement) => el.value.slice(el.selectionStart!, el.selectionEnd!))).toBe(
|
||||
(await name.inputValue()).replace(/\.md$/, ""),
|
||||
);
|
||||
for (const width of [1100, 430]) {
|
||||
await page.setViewportSize({ width, height: 560 });
|
||||
const [nameBox, targetBox] = await Promise.all([name.boundingBox(), target.boundingBox()]);
|
||||
expect(nameBox!.x).toBeCloseTo(targetBox!.x, 0);
|
||||
expect(targetBox!.x).toBeGreaterThan((await dialog.getByText("To directory:", { exact: true }).boundingBox())!.x);
|
||||
await expect(dialog.locator("[data-dialog-footer]").getByRole("checkbox")).toBeInViewport();
|
||||
}
|
||||
await name.fill("release-notes.md");
|
||||
await target.fill("src");
|
||||
await openCopy.check();
|
||||
await dialog.getByRole("button", { name: "OK", exact: true }).click();
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect(page.getByRole("tab", { name: "release-notes.md" })).toBeVisible();
|
||||
});
|
||||
@@ -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 }]);
|
||||
});
|
||||
@@ -53,7 +53,8 @@ test("Python syntax supplements retain PyCharm colours without a language server
|
||||
await expect(page.locator(".cm-sem-python-predefined-definition")).toHaveCSS("color", "rgb(187, 153, 34)");
|
||||
await expect(page.locator(".cm-sem-python-predefined-usage")).toHaveCSS("color", "rgb(204, 170, 51)");
|
||||
await expect(page.locator(".cm-sem-keyword").filter({ hasText: /^type$/ })).toHaveCSS("color", "rgb(17, 34, 51)");
|
||||
await expect(page.locator(".cm-sem-unused")).toHaveCSS("color", "rgb(111, 115, 122)");
|
||||
// The scheme is Darcula-based and doesn't name NOT_USED_ELEMENT_ATTRIBUTES: Darcula's #72737A applies.
|
||||
await expect(page.locator(".cm-sem-unused")).toHaveCSS("color", "rgb(114, 115, 122)");
|
||||
expect(errors).toEqual([]);
|
||||
await page.screenshot({ path: info.outputPath("python-highlighting.png") });
|
||||
});
|
||||
@@ -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" },
|
||||
]);
|
||||
});
|
||||
@@ -84,7 +84,8 @@ test("Recent Locations keeps all snippet lines visible when the editor font grow
|
||||
await expect(code).toHaveCSS("font-size", "19px");
|
||||
await expect(code).toHaveCSS("line-height", "30px");
|
||||
await expect(code).toHaveCSS("font-family", /"Fira Code".*"Maple Mono NF CN"/);
|
||||
expect((await code.boundingBox())!.height).toBe(90);
|
||||
// Three 30px lines; layout may land on a fractional pixel.
|
||||
expect((await code.boundingBox())!.height).toBeCloseTo(90, 0);
|
||||
|
||||
await page.setViewportSize({ width: 400, height: 500 });
|
||||
const filter = dialog.getByRole("textbox", { name: "Filter recent locations" });
|
||||
|
||||
@@ -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,79 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("the environment editor resizes both tables and focuses a new variable", async ({ workbench: page }) => {
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(async () => {
|
||||
const path = "/src/features/run/store.ts";
|
||||
const { useRun } = await import(/* @vite-ignore */ path);
|
||||
window.__ipc.handlers.run_system_env = () =>
|
||||
Object.fromEntries(Array.from({ length: 28 }, (_, i) => [`SYSTEM_${i + 1}`, `example-${i + 1}`]));
|
||||
useRun.setState({
|
||||
configs: [
|
||||
{
|
||||
id: "layout:env",
|
||||
kind: "shell",
|
||||
name: "Environment example",
|
||||
command: "npm",
|
||||
args: ["start"],
|
||||
env: Object.fromEntries(Array.from({ length: 18 }, (_, i) => [`APP_${i + 1}`, `value-${i + 1}`])),
|
||||
detected: false,
|
||||
isTest: false,
|
||||
debugAdapter: null,
|
||||
},
|
||||
],
|
||||
selectedId: "layout:env",
|
||||
loaded: true,
|
||||
editorOpen: true,
|
||||
});
|
||||
});
|
||||
const configurations = page.getByRole("dialog", { name: "Run/Debug Configurations", exact: true });
|
||||
const edit = configurations.getByRole("button", { name: "Edit Environment Variables" });
|
||||
await edit.click();
|
||||
const dialog = page.getByRole("dialog", { name: "Environment Variables", exact: true });
|
||||
const user = dialog.getByRole("table", { name: "User environment variables" });
|
||||
const system = dialog.getByRole("table", { name: "System environment variables" });
|
||||
await expect(system.getByRole("row")).toHaveCount(29);
|
||||
|
||||
const userHeight = (await user.boundingBox())!.height;
|
||||
const systemHeight = (await system.boundingBox())!.height;
|
||||
const handle = dialog.getByRole("separator", { name: "Resize" });
|
||||
await expect(handle).toBeVisible();
|
||||
const { x, y } = (await handle.boundingBox())!;
|
||||
await page.mouse.move(x + 5, y + 5);
|
||||
await page.mouse.down();
|
||||
await page.mouse.move(x + 5, y + 101, { steps: 5 });
|
||||
await page.mouse.up();
|
||||
await expect.poll(async () => (await user.boundingBox())!.height).toBeGreaterThan(userHeight + 30);
|
||||
await expect.poll(async () => (await system.boundingBox())!.height).toBeGreaterThan(systemHeight + 30);
|
||||
|
||||
await system.evaluate((el) => (el.scrollTop = el.scrollHeight));
|
||||
expect(await system.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
expect(await user.evaluate((el) => el.scrollTop)).toBe(0);
|
||||
const columnHeader = (await system.getByRole("columnheader", { name: "Name" }).boundingBox())!;
|
||||
expect(columnHeader.y).toBeGreaterThanOrEqual((await system.boundingBox())!.y);
|
||||
expect(columnHeader.y).toBeLessThan((await system.boundingBox())!.y + columnHeader.height);
|
||||
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await page.setViewportSize({ width: 430, height: 530 });
|
||||
await edit.click();
|
||||
await dialog.getByRole("button", { name: "Add", exact: true }).click();
|
||||
const name = user.getByRole("textbox", { name: "Variable 19 name", exact: true });
|
||||
await expect(name).toBeFocused();
|
||||
await expect(name).toBeInViewport();
|
||||
expect(await user.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
await name.fill("APP_1");
|
||||
await expect(dialog.getByRole("alert")).toHaveText("Duplicate environment variable: APP_1");
|
||||
const ok = dialog.getByRole("button", { name: "OK", exact: true });
|
||||
await expect(ok).toBeDisabled();
|
||||
await expect(ok).toBeInViewport({ ratio: 1 });
|
||||
await expect(dialog.getByRole("button", { name: "Cancel", exact: true })).toBeInViewport({ ratio: 1 });
|
||||
await name.fill("LOG_LEVEL");
|
||||
await user.getByRole("textbox", { name: "Variable 19 value", exact: true }).fill("debug");
|
||||
await dialog.getByRole("checkbox", { name: "Include system environment variables" }).uncheck();
|
||||
await ok.click();
|
||||
await expect(configurations.getByRole("textbox", { name: "Environment variables", exact: true })).toHaveValue(
|
||||
/LOG_LEVEL=debug/,
|
||||
);
|
||||
await edit.click();
|
||||
await expect(dialog.getByRole("checkbox", { name: "Include system environment variables" })).not.toBeChecked();
|
||||
});
|
||||
@@ -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,63 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("keeps scope navigation and editing usable as Settings narrows", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1180, height: 770 });
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await expect(dialog).toBeVisible();
|
||||
const longName = "Shared API and generated deployment artifacts for regional settlement services";
|
||||
const longPattern = "file:services/settlement//*.ts && !file:*.test.ts";
|
||||
await page.evaluate(
|
||||
async ({ longName, longPattern }) => {
|
||||
const path = "/src/features/settings/model/staging.ts";
|
||||
const { selectPage, stage } = await import(/* @vite-ignore */ path);
|
||||
stage("scopes", "project", "scopes", [
|
||||
{ name: longName, pattern: longPattern },
|
||||
...Array.from({ length: 23 }, (_, i) => ({
|
||||
name: `Settlement area ${i + 1}`,
|
||||
pattern: `file:services/area-${i + 1}//*.ts`,
|
||||
})),
|
||||
]);
|
||||
selectPage("scopes");
|
||||
},
|
||||
{ longName, longPattern },
|
||||
);
|
||||
const scopes = dialog.getByRole("listbox", { name: "Scopes", exact: true });
|
||||
const toolbar = dialog.getByRole("toolbar", { name: "Scopes actions" });
|
||||
const name = dialog.getByRole("textbox", { name: /^Name:?$/ });
|
||||
const pattern = dialog.getByRole("textbox", { name: /^Pattern:?$/ });
|
||||
await expect(name).toHaveValue(longName);
|
||||
await expect(pattern).toHaveValue(longPattern);
|
||||
expect((await name.boundingBox())!.x).toBeGreaterThan(
|
||||
(await scopes.boundingBox())!.x + (await scopes.boundingBox())!.width,
|
||||
);
|
||||
const first = scopes.getByRole("option", { name: longName, exact: true });
|
||||
await expect(first.getByTitle(new RegExp(longName))).toBeVisible();
|
||||
expect(await scopes.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
|
||||
await scopes.focus();
|
||||
await page.keyboard.press("End");
|
||||
const last = scopes.getByRole("option", { name: "Settlement area 23", exact: true });
|
||||
await expect(last).toHaveAttribute("aria-selected", "true");
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(pattern).toHaveValue("file:services/area-23//*.ts");
|
||||
expect(await scopes.evaluate((el) => el.scrollTop)).toBeGreaterThan(100);
|
||||
await expect(toolbar).toBeInViewport({ ratio: 1 });
|
||||
|
||||
await page.setViewportSize({ width: 650, height: 730 });
|
||||
const listBounds = (await scopes.boundingBox())!;
|
||||
expect((await name.boundingBox())!.y).toBeGreaterThan(listBounds.y + listBounds.height);
|
||||
await toolbar.getByRole("button", { name: "Add", exact: true }).click();
|
||||
await expect(name).toBeFocused();
|
||||
await expect(name).toHaveValue("Scope");
|
||||
expect(await name.evaluate((el: HTMLInputElement) => [el.selectionStart, el.selectionEnd])).toEqual([0, 5]);
|
||||
const added = scopes.getByRole("option", { name: "Scope", exact: true });
|
||||
await expect(added).toHaveAttribute("aria-selected", "true");
|
||||
await expect(added).toBeInViewport({ ratio: 1 });
|
||||
await page.keyboard.type("Settlement exports");
|
||||
await pattern.fill("file:exports//*.csv");
|
||||
await expect(scopes.getByRole("option", { name: "Settlement exports", exact: true })).toHaveAttribute(
|
||||
"aria-selected",
|
||||
"true",
|
||||
);
|
||||
});
|
||||
@@ -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");
|
||||
});
|
||||
Loaded 100 of 373 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача