дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-21 00:50:47 +02:00
Порівняти коміти
141
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
478939fcfa | ||
|
|
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 | ||
|
|
9fe1dd8d7b | ||
|
|
c0b243f020 | ||
|
|
96f3818bf2 | ||
|
|
adf17d030e | ||
|
|
815bebf4ec | ||
|
|
2b75b79ea0 | ||
|
|
2c6329012a | ||
|
|
f40bcd747f | ||
|
|
c752f007be | ||
|
|
bcdff6886f | ||
|
|
b7e9276b0f | ||
|
|
6023e391bc | ||
|
|
3d80e661b7 | ||
|
|
b66439ceda | ||
|
|
899fe888b7 | ||
|
|
e7de2aaf6d | ||
|
|
9293b13737 | ||
|
|
d1f79d05b3 | ||
|
|
176c43c908 | ||
|
|
20b6b0aed5 | ||
|
|
101a0862e4 | ||
|
|
b48f0b6071 | ||
|
|
a9b16c3e06 | ||
|
|
abd55f88b5 | ||
|
|
dac4db0994 | ||
|
|
b0d0ea868b | ||
|
|
d86ff872af | ||
|
|
dbef3cdc96 | ||
|
|
c483c3b76f | ||
|
|
da79a73def | ||
|
|
2cc54b35f6 | ||
|
|
097221c1b3 | ||
|
|
1bb4ffe6b2 | ||
|
|
51e525336b | ||
|
|
1b47bc2c14 | ||
|
|
aa1326496b | ||
|
|
7850429174 | ||
|
|
3dd5c75fa0 | ||
|
|
36ecb53159 | ||
|
|
006405ca11 | ||
|
|
40b95650cf | ||
|
|
0a571c0b4d | ||
|
|
b1f88bf79c | ||
|
|
0a6b3d011f | ||
|
|
fd9b20fa05 | ||
|
|
4f5622d72c | ||
|
|
f4a7a7bafb | ||
|
|
737afc6a8d | ||
|
|
6bf75155b6 | ||
|
|
bbedf7e1f6 | ||
|
|
42fd0fa8e0 | ||
|
|
97a41ae983 | ||
|
|
f29903b698 | ||
|
|
610fe23f88 | ||
|
|
59376b9718 | ||
|
|
170fd735dd | ||
|
|
e0ae9e764c | ||
|
|
19c1b72650 | ||
|
|
06ff2e51c3 | ||
|
|
6ae31b8148 | ||
|
|
3783b601b5 | ||
|
|
37044dcd89 | ||
|
|
1a2adab237 | ||
|
|
9ed87d77a7 | ||
|
|
9f4731189d | ||
|
|
92ccfac192 | ||
|
|
60d335eec0 | ||
|
|
a679e8086f | ||
|
|
4c20aa5c8d | ||
|
|
d19d74120b |
No files matched your search
Створено
@@ -4156,6 +4156,8 @@ dependencies = [
|
||||
"ide-vcs",
|
||||
"ide-vfs",
|
||||
"parking_lot",
|
||||
"rustix",
|
||||
"semver",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"specta",
|
||||
@@ -4511,6 +4513,7 @@ dependencies = [
|
||||
name = "ide-http"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"hyper-util",
|
||||
"ide-core",
|
||||
"ide-vfs",
|
||||
"parking_lot",
|
||||
@@ -5017,6 +5020,7 @@ dependencies = [
|
||||
"ignore",
|
||||
"notify",
|
||||
"parking_lot",
|
||||
"rayon",
|
||||
"rustix",
|
||||
"serde",
|
||||
"serde_json",
|
||||
|
||||
@@ -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"] }
|
||||
@@ -51,7 +51,7 @@ async fn run_once(
|
||||
move || launch.resolve_for_launch_with_copilot_env(&root, strip_ambient)
|
||||
})
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
.map_err(|e| e.to_string())??;
|
||||
let cwd = dunce::canonicalize(&root).unwrap_or(root);
|
||||
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), ..Default::default() });
|
||||
let client = Dialect::wrap(updates.clone());
|
||||
|
||||
@@ -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::*;
|
||||
|
||||
@@ -132,6 +134,7 @@ pub type McpExecutableFn = dyn Fn() -> Option<PathBuf> + Send + Sync;
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
||||
struct CopilotBinaryKey {
|
||||
command: String,
|
||||
github_account: Option<String>,
|
||||
modified: Option<std::time::SystemTime>,
|
||||
len: Option<u64>,
|
||||
}
|
||||
@@ -140,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>>>,
|
||||
@@ -193,6 +196,7 @@ impl Shared {
|
||||
let metadata = std::fs::metadata(&executable).ok();
|
||||
CopilotBinaryKey {
|
||||
command: executable.to_string_lossy().into_owned(),
|
||||
github_account: provider::copilot_github_account(&spec.env),
|
||||
modified: metadata.as_ref().and_then(|m| m.modified().ok()),
|
||||
len: metadata.as_ref().map(std::fs::Metadata::len),
|
||||
}
|
||||
@@ -211,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.
|
||||
@@ -559,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,
|
||||
@@ -602,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);
|
||||
@@ -1126,6 +1142,16 @@ impl AgentManager {
|
||||
/// Changes a session setting (model, mode…): right away when the agent runs, else when it next starts.
|
||||
pub async fn set_config(&self, id: &str, option: &str, value: String) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
let provider = task.state.lock().task.provider.clone();
|
||||
let discovered = self
|
||||
.shared
|
||||
.paths
|
||||
.catalogs
|
||||
.cached(&self.shared, &provider)
|
||||
.config
|
||||
.iter()
|
||||
.find(|o| o.id == option && o.category.as_deref() == Some("model"))
|
||||
.cloned();
|
||||
let (target, change) = {
|
||||
let mut s = task.state.lock();
|
||||
let busy = s.busy;
|
||||
@@ -1146,17 +1172,19 @@ impl AgentManager {
|
||||
task.emit_task();
|
||||
return Ok(());
|
||||
}
|
||||
let target = s
|
||||
.task
|
||||
.config
|
||||
.iter()
|
||||
.find(|o| o.id == option)
|
||||
.ok_or_else(|| IdeError::not_found("no such setting"))?
|
||||
.clone();
|
||||
let session_target = s.task.config.iter().find(|o| o.id == option).cloned();
|
||||
let recovered_model = session_target.is_none();
|
||||
let target = match session_target {
|
||||
Some(target) => target,
|
||||
None if discovered.is_some() => discovered.unwrap(),
|
||||
None => return Err(IdeError::not_found("no such setting")),
|
||||
};
|
||||
if s.pending_model.is_some() && config::is_per_model_option(&target) {
|
||||
return Err(IdeError::invalid("This setting is not available on the selected model"));
|
||||
}
|
||||
if !target.values.iter().any(|v| v.value == value) {
|
||||
if recovered_model {
|
||||
(target, None)
|
||||
} else if !target.values.iter().any(|v| v.value == value) {
|
||||
if target.category.as_deref() != Some("model") {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
}
|
||||
@@ -1543,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)?;
|
||||
@@ -1974,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();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2799,9 +2839,12 @@ impl Task {
|
||||
pending_model: Option<&PendingModel>,
|
||||
) -> Result<Live, SessionOpenError> {
|
||||
let launch_cwd = cwd.to_path_buf();
|
||||
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
|
||||
.await
|
||||
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?;
|
||||
let mut spec = tokio::task::spawn_blocking(move || {
|
||||
spec.resolve_for_launch_with_copilot_env(&launch_cwd, provider::prefer_stored_copilot_auth())
|
||||
})
|
||||
.await
|
||||
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?
|
||||
.map_err(|e| SessionOpenError { message: e, allow_acp_fallback: false })?;
|
||||
if spec.driver == provider::Driver::Acp && provider::is_copilot_provider(provider_id) {
|
||||
let mcp_overrides = self.state.lock().task.mcp_overrides.clone();
|
||||
for name in self.shared.mcp_servers_off_for_session(provider_id, &mcp_overrides) {
|
||||
@@ -3850,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"))?;
|
||||
|
||||
@@ -144,7 +144,8 @@ async fn discover_once(spec: ProviderSpec, cwd: PathBuf, strip_ambient: bool) ->
|
||||
move || spec.resolve_for_launch_with_copilot_env(&cwd, strip_ambient)
|
||||
})
|
||||
.await
|
||||
.map_err(|e| DiscoverError { message: e.to_string(), allow_acp_fallback: false })?;
|
||||
.map_err(|e| DiscoverError { message: e.to_string(), allow_acp_fallback: false })?
|
||||
.map_err(|e| DiscoverError { message: e, allow_acp_fallback: false })?;
|
||||
let cwd = dunce::canonicalize(&cwd).unwrap_or(cwd);
|
||||
let args = headless_args(&launch.args);
|
||||
let peer = Peer::spawn_framed(
|
||||
|
||||
@@ -312,7 +312,7 @@ impl Settings {
|
||||
}
|
||||
|
||||
/// Parses `models.list` + optional `models.listTokenPriceUnits` into catalog entries,
|
||||
/// prepending `"auto"` when not already in the list.
|
||||
/// prepending `"auto"` when direct models are present or Copilot advertises an enabled Auto tier.
|
||||
pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<ModelEntry> {
|
||||
let units = parse_price_units(price_units);
|
||||
let raw = list
|
||||
@@ -322,7 +322,7 @@ pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<Mo
|
||||
.map(Vec::as_slice)
|
||||
.unwrap_or_default();
|
||||
let mut out = Vec::new();
|
||||
if !raw.iter().any(|m| str_of(m, "id") == Some("auto")) && !raw.is_empty() {
|
||||
if !raw.iter().any(|m| str_of(m, "id") == Some("auto")) && (!raw.is_empty() || auto_model_available(list)) {
|
||||
out.push(ModelEntry {
|
||||
id: "auto".into(),
|
||||
name: "Auto".into(),
|
||||
@@ -344,6 +344,18 @@ pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<Mo
|
||||
out
|
||||
}
|
||||
|
||||
fn auto_model_available(list: &Value) -> bool {
|
||||
let Some(auto) = list.get("auto") else { return false };
|
||||
if auto.get("enabled").or_else(|| auto.pointer("/status/enabled")).and_then(Value::as_bool) == Some(false) {
|
||||
return false;
|
||||
}
|
||||
let Some(tiers) = auto.get("tiers").and_then(Value::as_array) else { return auto.is_object() };
|
||||
tiers.is_empty()
|
||||
|| tiers.iter().any(|tier| {
|
||||
tier.get("enabled").or_else(|| tier.pointer("/status/enabled")).and_then(Value::as_bool) != Some(false)
|
||||
})
|
||||
}
|
||||
|
||||
fn parse_model(m: &Value, units: &HashMap<String, PriceUnit>) -> Option<ModelEntry> {
|
||||
let id = str_of(m, "id")?.to_owned();
|
||||
if m.get("model_picker_enabled").and_then(Value::as_bool) == Some(false)
|
||||
|
||||
@@ -110,6 +110,72 @@ fn sample_price_units() -> Value {
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_an_enabled_auto_only_catalog() {
|
||||
let list = json!({
|
||||
"models": [],
|
||||
"auto": {
|
||||
"defaultTier": "balance",
|
||||
"tiers": [
|
||||
{
|
||||
"id": "balance",
|
||||
"displayName": "Standard",
|
||||
"type": "auto",
|
||||
"fusionTier": "standard",
|
||||
"status": { "enabled": true, "pickerVisible": true }
|
||||
},
|
||||
{
|
||||
"id": "hydrafusion",
|
||||
"displayName": "High",
|
||||
"type": "fusion",
|
||||
"fusionTier": "high",
|
||||
"status": {
|
||||
"enabled": false,
|
||||
"pickerVisible": true,
|
||||
"reason": "user_not_eligible"
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "fast",
|
||||
"displayName": "Fast",
|
||||
"type": "auto",
|
||||
"status": { "enabled": true, "pickerVisible": false }
|
||||
}
|
||||
],
|
||||
"providerId": "copilot"
|
||||
},
|
||||
"imageModels": []
|
||||
});
|
||||
|
||||
let catalog = models::parse_catalog(&list, None);
|
||||
assert_eq!(catalog.iter().map(|m| m.id.as_str()).collect::<Vec<_>>(), ["auto"]);
|
||||
assert_eq!(Settings::new(&catalog, &UserDefaults::default()).model, "auto");
|
||||
|
||||
let options =
|
||||
config::parse_options(&models::config_options(&catalog, &Settings::new(&catalog, &UserDefaults::default())));
|
||||
let model = options.iter().find(|option| option.id == MODEL).unwrap();
|
||||
assert_eq!(model.current.as_deref(), Some("auto"));
|
||||
assert_eq!(model.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(), ["auto"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_an_auto_only_catalog_when_every_tier_is_disabled() {
|
||||
let list = json!({
|
||||
"models": [],
|
||||
"auto": {
|
||||
"defaultTier": "balance",
|
||||
"tiers": [
|
||||
{
|
||||
"id": "balance",
|
||||
"status": { "enabled": false, "pickerVisible": true }
|
||||
}
|
||||
]
|
||||
}
|
||||
});
|
||||
|
||||
assert!(models::parse_catalog(&list, None).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_tiered_context_windows_pricing_and_uses_copilots_own_defaults() {
|
||||
let catalog = models::parse_catalog(&sample_models_list(), Some(&sample_price_units()));
|
||||
|
||||
@@ -9,6 +9,8 @@ use serde_json::Value;
|
||||
use std::collections::BTreeMap;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
pub(crate) const COPILOT_GITHUB_ACCOUNT_ENV: &str = "OPENIDEA_COPILOT_GITHUB_ACCOUNT";
|
||||
|
||||
/// The protocol an agent speaks. Native ones run behind an in-process ACP endpoint
|
||||
/// (`native`), so tasks see every agent as ACP and read features from its capabilities.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||
@@ -138,15 +140,31 @@ impl ProviderSpec {
|
||||
/// Resolve once before connecting, so authentication guidance names that same install.
|
||||
pub(crate) fn resolve_for_launch(self, cwd: &Path) -> Self {
|
||||
let strip = prefer_stored_copilot_auth();
|
||||
self.resolve_for_launch_with_copilot_env(cwd, strip)
|
||||
self.resolve_for_launch_base(cwd, strip)
|
||||
}
|
||||
|
||||
pub(crate) fn resolve_for_launch_with_copilot_env(mut self, cwd: &Path, strip_ambient_tokens: bool) -> Self {
|
||||
pub(crate) fn resolve_for_launch_with_copilot_env(
|
||||
self,
|
||||
cwd: &Path,
|
||||
strip_ambient_tokens: bool,
|
||||
) -> Result<Self, String> {
|
||||
let account = is_copilot_provider(&self.id).then(|| copilot_github_account(&self.env)).flatten();
|
||||
let mut resolved = self.resolve_for_launch_base(cwd, strip_ambient_tokens || account.is_some());
|
||||
if let Some(account) = account {
|
||||
let token = github_token_for_account(&account)?;
|
||||
resolved.env.retain(|(name, _)| !AMBIENT_COPILOT_AUTH_VARS.contains(&name.as_str()));
|
||||
resolved.env.push(("COPILOT_GITHUB_TOKEN".into(), token));
|
||||
}
|
||||
Ok(resolved)
|
||||
}
|
||||
|
||||
fn resolve_for_launch_base(mut self, cwd: &Path, strip_ambient_tokens: bool) -> Self {
|
||||
if self.driver != Driver::Acp {
|
||||
self.command = crate::native::newest_install(&self.command);
|
||||
}
|
||||
if is_copilot_provider(&self.id) {
|
||||
self.env = sanitized_copilot_env(&self.env, strip_ambient_tokens);
|
||||
self.env.retain(|(name, _)| name != COPILOT_GITHUB_ACCOUNT_ENV);
|
||||
}
|
||||
let program = ide_jsonrpc::resolve_spawn_program(&self.command, &self.env);
|
||||
self.command =
|
||||
@@ -164,6 +182,50 @@ pub(crate) fn is_copilot_provider(id: &str) -> bool {
|
||||
id == "copilot" || id.starts_with("copilot-")
|
||||
}
|
||||
|
||||
pub(crate) fn copilot_github_account(env: &[(String, String)]) -> Option<String> {
|
||||
env.iter()
|
||||
.rev()
|
||||
.find(|(name, _)| name == COPILOT_GITHUB_ACCOUNT_ENV)
|
||||
.map(|(_, value)| value.trim())
|
||||
.filter(|value| !value.is_empty())
|
||||
.map(str::to_owned)
|
||||
}
|
||||
|
||||
fn github_token_for_account(account: &str) -> Result<String, String> {
|
||||
let path = ide_core::process::shell_env()
|
||||
.find(|(name, _)| name == "PATH")
|
||||
.map(|(_, value)| value)
|
||||
.or_else(|| ide_core::process::host_var_os("PATH"));
|
||||
let program = path
|
||||
.as_deref()
|
||||
.and_then(|path| ide_core::process::find_executable("gh", path))
|
||||
.ok_or_else(|| "GitHub CLI (`gh`) is required to select a Copilot GitHub account".to_owned())?;
|
||||
let mut command = std::process::Command::new(program);
|
||||
command.args(["auth", "token", "--hostname", "github.com", "--user", account]).envs(ide_core::process::shell_env());
|
||||
for name in AMBIENT_COPILOT_AUTH_VARS {
|
||||
command.env_remove(name);
|
||||
}
|
||||
let output = command
|
||||
.output()
|
||||
.map_err(|error| format!("Couldn't read GitHub authentication for account {account}: {error}"))?;
|
||||
if !output.status.success() {
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
let detail = stderr.trim();
|
||||
return Err(if detail.is_empty() {
|
||||
format!("GitHub CLI has no authenticated account named {account}")
|
||||
} else {
|
||||
format!("Couldn't use GitHub account {account}: {detail}")
|
||||
});
|
||||
}
|
||||
let token = String::from_utf8(output.stdout)
|
||||
.map_err(|_| format!("GitHub CLI returned a non-text token for account {account}"))?;
|
||||
let token = token.trim();
|
||||
if token.is_empty() {
|
||||
return Err(format!("GitHub CLI returned no token for account {account}"));
|
||||
}
|
||||
Ok(token.to_owned())
|
||||
}
|
||||
|
||||
pub(crate) fn prefer_stored_copilot_auth() -> bool {
|
||||
PREFER_STORED_COPILOT_AUTH.load(std::sync::atomic::Ordering::Acquire)
|
||||
}
|
||||
@@ -311,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(),
|
||||
@@ -339,6 +402,31 @@ pub(crate) fn set_builtin_env(
|
||||
id: &str,
|
||||
env: BTreeMap<String, String>,
|
||||
) -> IdeResult<()> {
|
||||
if id == "copilot" {
|
||||
let file = custom_dir.join("copilot.toml");
|
||||
if file.try_exists()?
|
||||
&& let mut agent = CustomAgent::read_with(&file, id, secrets).map_err(IdeError::invalid)?
|
||||
&& agent.registry.is_some()
|
||||
{
|
||||
let existing = agent.env.clone();
|
||||
let mut existing_launch_env = existing.clone();
|
||||
let mut next_launch_env = env.clone();
|
||||
existing_launch_env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
|
||||
next_launch_env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
|
||||
if existing_launch_env != next_launch_env {
|
||||
return Err(IdeError::invalid(format!("{id} is installed from the ACP Registry")));
|
||||
}
|
||||
match env.get(COPILOT_GITHUB_ACCOUNT_ENV).filter(|value| !value.trim().is_empty()) {
|
||||
Some(account) => {
|
||||
agent.env.insert(COPILOT_GITHUB_ACCOUNT_ENV.into(), account.trim().into());
|
||||
}
|
||||
None => {
|
||||
agent.env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
|
||||
}
|
||||
}
|
||||
return agent.write(&file).map_err(Into::into);
|
||||
}
|
||||
}
|
||||
update_builtin(custom_dir, secrets, id, |agent, _| agent.env = env)
|
||||
}
|
||||
|
||||
@@ -955,6 +1043,46 @@ mod tests {
|
||||
set_builtin_env(dir.path(), None, "not-a-builtin", env).unwrap_err();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn registry_copilot_allows_only_the_github_account_override() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let file = dir.path().join("copilot.toml");
|
||||
CustomAgent {
|
||||
name: Some("GitHub Copilot".into()),
|
||||
driver: Driver::Acp,
|
||||
command: "/tools/copilot".into(),
|
||||
args: vec!["--acp".into()],
|
||||
env: BTreeMap::from([("REGISTRY_SETTING".into(), "kept".into())]),
|
||||
registry: Some(RegistryRef { id: "copilot".into(), version: "1.0.0".into() }),
|
||||
}
|
||||
.write(&file)
|
||||
.unwrap();
|
||||
|
||||
set_builtin_env(
|
||||
dir.path(),
|
||||
None,
|
||||
"copilot",
|
||||
BTreeMap::from([
|
||||
("REGISTRY_SETTING".into(), "kept".into()),
|
||||
(COPILOT_GITHUB_ACCOUNT_ENV.into(), "dengliu_microsoft".into()),
|
||||
]),
|
||||
)
|
||||
.unwrap();
|
||||
let spec = load(Some(dir.path()), None).into_iter().find(|spec| spec.id == "copilot").unwrap();
|
||||
assert_eq!(copilot_github_account(&spec.env).as_deref(), Some("dengliu_microsoft"));
|
||||
|
||||
set_builtin_env(dir.path(), None, "copilot", BTreeMap::from([("REGISTRY_SETTING".into(), "changed".into())]))
|
||||
.unwrap_err();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn launch_metadata_never_passes_the_github_account_control_to_copilot() {
|
||||
let mut spec = builtin_spec("copilot").unwrap();
|
||||
spec.env.push((COPILOT_GITHUB_ACCOUNT_ENV.into(), "dengliu_microsoft".into()));
|
||||
let resolved = spec.resolve_for_launch(Path::new("."));
|
||||
assert!(resolved.env.iter().all(|(name, _)| name != COPILOT_GITHUB_ACCOUNT_ENV));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn acp_adapters_of_native_agents_are_unlisted_until_customized() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -537,6 +537,14 @@ fn install_entry_with(
|
||||
return Err(e);
|
||||
}
|
||||
};
|
||||
let github_account = (entry.id == "copilot")
|
||||
.then(|| CustomAgent::read(&file).ok())
|
||||
.flatten()
|
||||
.and_then(|agent| agent.env.get(provider::COPILOT_GITHUB_ACCOUNT_ENV).cloned());
|
||||
let mut env = env;
|
||||
if let Some(account) = github_account {
|
||||
env.insert(provider::COPILOT_GITHUB_ACCOUNT_ENV.into(), account);
|
||||
}
|
||||
let agent = CustomAgent {
|
||||
name: Some(entry.name.clone()),
|
||||
driver: Driver::Acp,
|
||||
|
||||
@@ -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");
|
||||
@@ -2333,6 +2362,56 @@ async fn idle_model_switches_discover_controls_and_no_control_models_without_ano
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn session_without_a_model_option_can_select_from_a_recovered_catalog() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
*agent.model_options.lock() = HashMap::from([
|
||||
("big".into(), effort_options(&["low", "high"], "high")),
|
||||
("small".into(), effort_options(&["minimal", "medium"], "minimal")),
|
||||
]);
|
||||
let mgr = manager(tmp.path(), agent);
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("again"),
|
||||
provider: "claude-acp".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
|
||||
let spec = mgr.shared.spec("claude-acp").unwrap();
|
||||
let (_, flight) = mgr.shared.paths.catalogs.request(&mgr.shared, spec, true, None);
|
||||
if let Some(mut ready) = flight {
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while !*ready.borrow_and_update() {
|
||||
ready.changed().await.unwrap();
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
{
|
||||
let task = mgr.task(&task.id).unwrap();
|
||||
let mut state = task.state.lock();
|
||||
state.task.config.retain(|option| option.category.as_deref() != Some("model"));
|
||||
state.task.model = Some("stale-model".into());
|
||||
}
|
||||
|
||||
mgr.set_config(&task.id, "model", "small".into()).await.unwrap();
|
||||
let task = mgr.task(&task.id).unwrap();
|
||||
{
|
||||
let state = task.state.lock();
|
||||
assert_eq!(state.task.model.as_deref(), Some("small"));
|
||||
let model = state.task.config.iter().find(|option| option.category.as_deref() == Some("model")).unwrap();
|
||||
assert_eq!(model.current.as_deref(), Some("small"));
|
||||
assert!(model.values.iter().any(|value| value.value == "small"));
|
||||
}
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn idle_model_discovery_failure_restores_the_previous_choice_without_claiming_no_controls() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -82,11 +82,23 @@ pub fn load_linked(
|
||||
maven_repo: Option<PathBuf>,
|
||||
settings: &ide_core::settings::MavenSettings,
|
||||
gradle_settings: &ide_core::settings::GradleSettings,
|
||||
) -> BuildModel {
|
||||
load_linked_with_jdk(root, cache_dir, maven_repo, settings, gradle_settings, None)
|
||||
}
|
||||
|
||||
/// [`load_linked`] with the JDK Maven runs on, for JDK-activated Maven profiles.
|
||||
pub fn load_linked_with_jdk(
|
||||
root: &Path,
|
||||
cache_dir: &Path,
|
||||
maven_repo: Option<PathBuf>,
|
||||
settings: &ide_core::settings::MavenSettings,
|
||||
gradle_settings: &ide_core::settings::GradleSettings,
|
||||
maven_jdk_version: Option<u32>,
|
||||
) -> BuildModel {
|
||||
let maven = maven::has_projects(root, settings).then(|| {
|
||||
let profiles = settings.profiles(&sync::maven_profiles(cache_dir));
|
||||
let repo = maven_repo.or_else(maven::default_local_repo);
|
||||
let mut m = maven::load_with_linked(root, repo, &profiles, &settings.linked_projects);
|
||||
let mut m = maven::load_with_linked_jdk(root, repo, &profiles, maven_jdk_version, &settings.linked_projects);
|
||||
maven::UnlinkedProjects::from_model(&m, settings).filter(&mut m);
|
||||
// The user settings' profiles can be chosen too (`-P` applies to them as well).
|
||||
for p in maven::user_settings_file(root, settings).map(|f| maven::settings_profiles(&f)).unwrap_or_default() {
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -100,16 +100,6 @@ pub struct AgentSettings {
|
||||
pub smooth_text: bool,
|
||||
/// Conversations and the composer expand to the full width of the pane instead of staying in a centred column.
|
||||
pub fit_window_width: bool,
|
||||
/// While the agent works, playful words fill the pauses in what it reports.
|
||||
pub playful_status: bool,
|
||||
/// Seconds the agent reports nothing new before the playful words take over; 0 shows them
|
||||
/// from the start.
|
||||
pub playful_after_seconds: u32,
|
||||
/// The user's playful words by activity (`working`, `thinking`, `reading`, …), replacing
|
||||
/// the built-in ones of that activity; an empty list keeps its status factual.
|
||||
#[serde(deserialize_with = "or_default")]
|
||||
#[specta(type = BTreeMap<String, Vec<String>>)]
|
||||
pub playful_words: BTreeMap<String, Vec<String>>,
|
||||
#[serde(deserialize_with = "or_default")]
|
||||
#[specta(type = ThinkingDisplay)]
|
||||
pub thinking: ThinkingDisplay,
|
||||
@@ -152,9 +142,6 @@ impl Default for AgentSettings {
|
||||
fold_turns: true,
|
||||
smooth_text: true,
|
||||
fit_window_width: false,
|
||||
playful_status: false,
|
||||
playful_after_seconds: 0,
|
||||
playful_words: BTreeMap::new(),
|
||||
thinking: ThinkingDisplay::Auto,
|
||||
tool_calls: ToolCallDisplay::Grouped,
|
||||
expand_tool_output: false,
|
||||
|
||||
@@ -76,6 +76,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 +119,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,
|
||||
@@ -176,6 +179,8 @@ pub struct CommitSettings {
|
||||
pub agent_model: String,
|
||||
/// That model's thinking level for commit messages; empty keeps the agent's.
|
||||
pub agent_effort: String,
|
||||
/// Show the Generate Commit Message with Agent button above the commit message.
|
||||
pub agent_button: bool,
|
||||
}
|
||||
|
||||
impl Default for CommitSettings {
|
||||
@@ -201,6 +206,7 @@ impl Default for CommitSettings {
|
||||
agent: String::new(),
|
||||
agent_model: String::new(),
|
||||
agent_effort: String::new(),
|
||||
agent_button: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -606,3 +612,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);
|
||||
}
|
||||
}
|
||||
@@ -217,7 +217,8 @@ impl ManageConnection for MssqlConnectionManager {
|
||||
let row = client.simple_query("SELECT DB_NAME()").await?.into_row().await?;
|
||||
let default = row
|
||||
.and_then(|r| r.get::<&str, _>(0).map(str::to_owned))
|
||||
.and_then(|db| crate::sql::use_schema(DbDriver::SqlServer, &db));
|
||||
// Statements that `USE` another database must not move the pooled connection for good.
|
||||
.map(|db| format!("USE {}", crate::sql::quote_ident(DbDriver::SqlServer, &db)));
|
||||
Ok(MssqlConnection(Some(client), Context::new(default)))
|
||||
}
|
||||
|
||||
@@ -748,6 +749,14 @@ impl Pool {
|
||||
}
|
||||
|
||||
/// The keep-alive ping (Oracle needs a FROM clause).
|
||||
/// Keep-alive: one cheap round trip on the session.
|
||||
pub async fn ping(&self) -> IdeResult<()> {
|
||||
match self {
|
||||
Pool::Jdbc(p) => p.ping().await,
|
||||
_ => self.rows(self.ping_sql(), 1).await.map(|_| ()),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn ping_sql(&self) -> &'static str {
|
||||
match self {
|
||||
Pool::Oracle(_) => "SELECT 1 FROM DUAL",
|
||||
|
||||
@@ -5,6 +5,7 @@ use crate::{DataSource, DbManager, QueryResult, ResultColumn};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::HashMap;
|
||||
use std::io::{Cursor, Read};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Stdio;
|
||||
@@ -458,6 +459,44 @@ impl JdbcPool {
|
||||
}
|
||||
|
||||
async fn request(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
|
||||
let result = self.exchange_once(fields, sql, cancel).await;
|
||||
if let Err(e) = &result
|
||||
&& fields.first() != Some(&"open")
|
||||
&& e.kind != ide_core::error::ErrorKind::Cancelled
|
||||
&& !self.is_closed()
|
||||
&& !self.session_valid().await
|
||||
{
|
||||
// The session is gone (a proxy or tunnel dropped the idle TCP connection): close the
|
||||
// pool so the next statement or Connect starts a new one instead of failing forever.
|
||||
self.close().await;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Keep-alive: checks the session (any SQL would be dialect-specific) and closes a dead one.
|
||||
pub(crate) async fn ping(&self) -> IdeResult<()> {
|
||||
if self.session_valid().await {
|
||||
return Ok(());
|
||||
}
|
||||
self.close().await;
|
||||
Err(IdeError::new(ide_core::error::ErrorKind::Io, "JDBC connection was lost"))
|
||||
}
|
||||
|
||||
/// Whether the JDBC session still works, asked after a failed statement.
|
||||
async fn session_valid(&self) -> bool {
|
||||
if self.bridge.lock().await.is_none() {
|
||||
return false;
|
||||
}
|
||||
let cancel = CancellationToken::new();
|
||||
match tokio::time::timeout(Duration::from_secs(10), self.exchange_once(&["valid"], "", &cancel)).await {
|
||||
Ok(Ok(result)) => {
|
||||
result.rows.first().and_then(|row| row.first()).cloned().flatten().as_deref() != Some("false")
|
||||
}
|
||||
Ok(Err(_)) | Err(_) => false,
|
||||
}
|
||||
}
|
||||
|
||||
async fn exchange_once(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
|
||||
let mut slot = tokio::select! {
|
||||
biased;
|
||||
() = cancel.cancelled() => return Err(IdeError::cancelled()),
|
||||
@@ -562,14 +601,32 @@ fn decode(data: &[u8], sql: &str, elapsed_ms: f64) -> IdeResult<QueryResult> {
|
||||
impl DbManager {
|
||||
pub(crate) async fn jdbc_completion(&self, id: &str, pool: &JdbcPool) -> IdeResult<crate::CompletionModel> {
|
||||
let mut tables = vec![];
|
||||
let schemas = self.schemas(id).await?;
|
||||
let mut column_count = 0;
|
||||
// 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 {
|
||||
pool.metadata(&["schemaColumns", schema]).await.map(schema_columns).unwrap_or_else(|e| {
|
||||
tracing::warn!("JDBC columns of {schema}: {}", e.message);
|
||||
HashMap::new()
|
||||
})
|
||||
} else {
|
||||
HashMap::new()
|
||||
};
|
||||
for table in self.tables(id, schema).await? {
|
||||
let columns = columns.remove(&table.name).unwrap_or_default();
|
||||
column_count += columns.len();
|
||||
tables.push(crate::CompletionTable {
|
||||
schema: schema.clone(),
|
||||
name: table.name,
|
||||
kind: table.kind,
|
||||
columns: vec![],
|
||||
columns,
|
||||
});
|
||||
if tables.len() >= crate::MAX_META_ROWS {
|
||||
break;
|
||||
@@ -594,10 +651,49 @@ impl DbManager {
|
||||
}
|
||||
}
|
||||
|
||||
/// The bridge's `schemaColumns` rows (table, name, type, nullable, default) by table.
|
||||
fn schema_columns(rows: Vec<Vec<Option<String>>>) -> HashMap<String, Vec<crate::CompletionColumn>> {
|
||||
let mut by_table: HashMap<String, Vec<crate::CompletionColumn>> = HashMap::new();
|
||||
for row in rows {
|
||||
let mut it = row.into_iter();
|
||||
let (Some(Some(table)), Some(Some(name))) = (it.next(), it.next()) else { continue };
|
||||
let data_type = it.next().flatten().unwrap_or_default();
|
||||
let nullable = it.next().flatten().as_deref() != Some("0");
|
||||
let has_default = it.next().flatten().is_some();
|
||||
by_table.entry(table).or_default().push(crate::CompletionColumn {
|
||||
name,
|
||||
data_type,
|
||||
nullable,
|
||||
primary_key: false,
|
||||
has_default,
|
||||
});
|
||||
}
|
||||
by_table
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn schema_columns_group_by_table() {
|
||||
let row = |t: &str, n: &str, null: &str, def: Option<&str>| {
|
||||
vec![Some(t.into()), Some(n.into()), Some("INT".into()), Some(null.into()), def.map(Into::into)]
|
||||
};
|
||||
let by_table = schema_columns(vec![
|
||||
row("orders", "id", "0", None),
|
||||
row("orders", "note", "1", Some("'none'")),
|
||||
row("items", "sku", "1", None),
|
||||
vec![None, Some("orphan".into())],
|
||||
]);
|
||||
let orders = &by_table["orders"];
|
||||
assert_eq!(orders.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["id", "note"]);
|
||||
assert_eq!((orders[0].nullable, orders[0].has_default), (false, false));
|
||||
assert_eq!((orders[1].nullable, orders[1].has_default), (true, true));
|
||||
assert_eq!(by_table["items"].len(), 1);
|
||||
assert_eq!(by_table.len(), 2);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn frame_codec_checks_both_16_mib_boundaries() {
|
||||
assert_eq!(encode(7, &["a"]).unwrap(), [0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, 1, b'a']);
|
||||
|
||||
@@ -379,8 +379,8 @@ pub(crate) fn keep_alive(pool: &Arc<Pool>, every: Duration) {
|
||||
loop {
|
||||
tick.tick().await;
|
||||
let Some(p) = pool.upgrade().filter(|p| !p.is_closed()) else { break };
|
||||
if let Err(e) = p.rows(p.ping_sql(), 1).await {
|
||||
tracing::debug!("keep-alive: {}", e.message);
|
||||
if let Err(e) = p.ping().await {
|
||||
tracing::info!("keep-alive: {}", e.message);
|
||||
}
|
||||
}
|
||||
});
|
||||
@@ -847,12 +847,12 @@ impl DbManager {
|
||||
}
|
||||
|
||||
pub fn is_connected(&self, id: &str) -> bool {
|
||||
self.pools.lock().contains_key(id)
|
||||
self.pools.lock().get(id).is_some_and(|p| !p.is_closed())
|
||||
}
|
||||
|
||||
/// Connected targets (data source ids, `<id>:<database>`).
|
||||
pub fn connected(&self) -> Vec<String> {
|
||||
self.pools.lock().keys().cloned().collect()
|
||||
self.pools.lock().iter().filter(|(_, p)| !p.is_closed()).map(|(id, _)| id.clone()).collect()
|
||||
}
|
||||
|
||||
/// The pool of target `id`, connecting first if needed.
|
||||
@@ -862,8 +862,13 @@ impl DbManager {
|
||||
if self.tunnels.lock().get(source_id).is_some_and(|t| t.is_closed()) {
|
||||
self.disconnect_source(source_id).await;
|
||||
}
|
||||
if let Some(p) = self.pools.lock().get(id) {
|
||||
return Ok(p.clone());
|
||||
let cached = self.pools.lock().get(id).cloned();
|
||||
if let Some(p) = cached {
|
||||
if !p.is_closed() {
|
||||
return Ok(p);
|
||||
}
|
||||
// The connection broke (a custom JDBC session whose TCP connection was dropped): reconnect.
|
||||
self.disconnect(id).await;
|
||||
}
|
||||
let source = self.source(id)?;
|
||||
let password = self.password(&source).await;
|
||||
@@ -917,7 +922,7 @@ impl DbManager {
|
||||
|
||||
/// Disconnects every database of data source `id`.
|
||||
pub async fn disconnect_source(&self, id: &str) {
|
||||
let targets: Vec<String> = self.connected().into_iter().filter(|t| split_target(t).0 == id).collect();
|
||||
let targets: Vec<String> = self.pools.lock().keys().filter(|t| split_target(t).0 == id).cloned().collect();
|
||||
for t in targets {
|
||||
self.disconnect(&t).await;
|
||||
}
|
||||
|
||||
@@ -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"));
|
||||
}
|
||||
}
|
||||
@@ -442,7 +442,8 @@ pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
|
||||
DbDriver::Sqlite | DbDriver::Jdbc => None,
|
||||
DbDriver::Postgres => Some("SELECT current_schema()"),
|
||||
DbDriver::Mysql => Some("SELECT DATABASE()"),
|
||||
DbDriver::SqlServer => Some("SELECT DB_NAME()"),
|
||||
// The login's default schema; the database is the console's target (IDEA's `database.schema`).
|
||||
DbDriver::SqlServer => Some("SELECT SCHEMA_NAME()"),
|
||||
DbDriver::Oracle => Some("SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') FROM DUAL"),
|
||||
DbDriver::Snowflake => Some("SELECT CURRENT_SCHEMA()"),
|
||||
}
|
||||
@@ -450,12 +451,13 @@ pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
|
||||
|
||||
/// The statement that makes unqualified names resolve in `schema` on the
|
||||
/// connection that runs it (a query console's active schema; `None`: the driver
|
||||
/// has no schema to switch — SQLite's `main`, ClickHouse's `USE` differs).
|
||||
/// has no schema to switch — SQLite's `main`, ClickHouse's `USE` differs, and SQL Server
|
||||
/// cannot change a session's default schema, so its console schema only scopes resolution).
|
||||
pub fn use_schema(driver: DbDriver, schema: &str) -> Option<String> {
|
||||
match driver {
|
||||
DbDriver::Sqlite | DbDriver::Clickhouse | DbDriver::Jdbc => None,
|
||||
DbDriver::Sqlite | DbDriver::Clickhouse | DbDriver::Jdbc | DbDriver::SqlServer => None,
|
||||
DbDriver::Postgres => Some(format!("SET search_path TO {}", quote_ident(driver, schema))),
|
||||
DbDriver::Mysql | DbDriver::SqlServer => Some(format!("USE {}", quote_ident(driver, schema))),
|
||||
DbDriver::Mysql => Some(format!("USE {}", quote_ident(driver, schema))),
|
||||
DbDriver::Oracle => Some(format!("ALTER SESSION SET CURRENT_SCHEMA = {}", quote_ident(driver, schema))),
|
||||
DbDriver::Snowflake => Some(format!("USE SCHEMA {}", quote_ident(driver, schema))),
|
||||
}
|
||||
@@ -1030,7 +1032,7 @@ mod tests {
|
||||
assert_eq!(quote_ident(DbDriver::SqlServer, "a]b"), "[a]]b]");
|
||||
assert_eq!(qualified(DbDriver::SqlServer, "dbo", "t"), "[dbo].[t]");
|
||||
assert_eq!(qualified(DbDriver::SqlServer, "", "t"), "[t]");
|
||||
assert_eq!(current_schema(DbDriver::SqlServer), Some("SELECT DB_NAME()"));
|
||||
assert_eq!(current_schema(DbDriver::SqlServer), Some("SELECT SCHEMA_NAME()"));
|
||||
assert_eq!(crate::conn::begin_statement(DbDriver::SqlServer), "BEGIN TRAN");
|
||||
assert_eq!(
|
||||
schemas(DbDriver::SqlServer, true),
|
||||
@@ -1149,7 +1151,7 @@ mod tests {
|
||||
fn schema_switch_statement_per_dialect() {
|
||||
assert_eq!(use_schema(DbDriver::Postgres, "app data"), Some("SET search_path TO \"app data\"".into()));
|
||||
assert_eq!(use_schema(DbDriver::Mysql, "a`b"), Some("USE `a``b`".into()));
|
||||
assert_eq!(use_schema(DbDriver::SqlServer, "app] data"), Some("USE [app]] data]".into()));
|
||||
assert_eq!(use_schema(DbDriver::SqlServer, "dbo"), None);
|
||||
assert_eq!(use_schema(DbDriver::Postgres, "a\"b"), Some("SET search_path TO \"a\"\"b\"".into()));
|
||||
assert_eq!(use_schema(DbDriver::Oracle, "a\"b"), Some("ALTER SESSION SET CURRENT_SCHEMA = \"a\"\"b\"".into()));
|
||||
assert!(sqlserver_databases().contains("state = 0 AND HAS_DBACCESS(name) = 1"));
|
||||
|
||||
@@ -90,7 +90,10 @@ async fn duckdb_custom_driver_through_database_manager() -> IdeResult<()> {
|
||||
assert!(result.has_more);
|
||||
assert_eq!(result.rows, vec![vec![Some("1".into()), None]]);
|
||||
assert_eq!(result.columns[1].name, "label");
|
||||
assert_eq!(db.completion("test").await?.default_schema, "main");
|
||||
let completion = db.completion("test").await?;
|
||||
assert_eq!(completion.default_schema, "main");
|
||||
let items = completion.tables.iter().find(|t| t.schema == "main" && t.name == "items").expect("items");
|
||||
assert_eq!(items.columns.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["id", "label"]);
|
||||
db.execute("test", "create temporary table session_marker as select 42 as id", 1, &c).await?;
|
||||
let stop = CancellationToken::new();
|
||||
let (cancelled, ()) =
|
||||
@@ -213,3 +216,36 @@ async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
|
||||
db.disconnect("test").await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "requires JDBC_FIXTURE_JAR (java/jdbc-bridge/build.py --test --out fixture.jar) and Java 17+"]
|
||||
async fn a_lost_session_reconnects_on_the_next_statement() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir()?;
|
||||
let db = manager(tmp.path());
|
||||
db.save_jdbc_driver(DbJdbcDriver {
|
||||
id: "fixture".into(),
|
||||
name: "Fixture".into(),
|
||||
jars: vec![std::env::var("JDBC_FIXTURE_JAR").unwrap()],
|
||||
class_name: "ai.openidea.jdbc.SelfTest$Fixture".into(),
|
||||
url_template: String::new(),
|
||||
})?;
|
||||
let source = DataSource {
|
||||
id: "test".into(),
|
||||
name: "Fixture".into(),
|
||||
driver: DbDriver::Jdbc,
|
||||
global: true,
|
||||
jdbc_driver: "fixture".into(),
|
||||
url: "jdbc:fixture:".into(),
|
||||
..Default::default()
|
||||
};
|
||||
db.save_sources(vec![source]).await?;
|
||||
let cancel = CancellationToken::new();
|
||||
db.execute("test", "first", 1, &cancel).await?;
|
||||
// The fixture's session reports itself invalid after "drop", like a connection a proxy reset.
|
||||
assert!(db.execute("test", "drop", 1, &cancel).await.unwrap_err().message.contains("connection reset"));
|
||||
assert!(!db.is_connected("test"), "a lost session is no longer listed as connected");
|
||||
assert_eq!(db.execute("test", "after reconnect", 1, &cancel).await?.affected, Some(1.0));
|
||||
assert!(db.is_connected("test"));
|
||||
db.disconnect("test").await;
|
||||
Ok(())
|
||||
}
|
||||
@@ -7,9 +7,10 @@
|
||||
|
||||
use crate::{
|
||||
COMPOSE_DIR, COMPOSE_FILES, COMPOSE_PROJECT, COMPOSE_SERVICE, ContainerOp, DockerAvailability, DockerContainer,
|
||||
DockerEndpoint, DockerImage, DockerNetwork, DockerObject, DockerSnapshot, DockerVolume, split_csv,
|
||||
DockerEndpoint, DockerImage, DockerImageLayer, DockerLogLine, DockerNetwork, DockerObject, DockerProcessList,
|
||||
DockerSnapshot, DockerVolume, split_csv,
|
||||
};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::Deserialize;
|
||||
use std::collections::BTreeMap;
|
||||
use std::io::{Read, Write};
|
||||
@@ -193,9 +194,15 @@ fn request(addr: &Address, method: &str, path: &str, timeout: Duration) -> IdeRe
|
||||
read_response(&mut conn)
|
||||
}
|
||||
|
||||
/// Reads an HTTP/1.1 response: head until `\r\n\r\n`, then the body per its
|
||||
/// framing (chunked, `Content-Length`, or until the connection closes).
|
||||
fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
|
||||
/// A response's status line and body framing.
|
||||
struct Head {
|
||||
status: u16,
|
||||
chunked: bool,
|
||||
length: Option<usize>,
|
||||
}
|
||||
|
||||
/// Reads an HTTP/1.1 response head until `\r\n\r\n`.
|
||||
fn read_head(stream: &mut impl Read) -> IdeResult<Head> {
|
||||
let mut head: Vec<u8> = Vec::new();
|
||||
let mut byte = [0u8; 1];
|
||||
loop {
|
||||
@@ -228,16 +235,27 @@ fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
|
||||
length = value.parse().ok();
|
||||
}
|
||||
}
|
||||
let body = if chunked {
|
||||
Ok(Head { status, chunked, length })
|
||||
}
|
||||
|
||||
/// Reads an HTTP/1.1 response: its head, then the body per its framing
|
||||
/// (chunked, `Content-Length`, or until the connection closes).
|
||||
fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
|
||||
let head = read_head(stream)?;
|
||||
let body = read_body(stream, &head)?;
|
||||
Ok(Response { status: head.status, body })
|
||||
}
|
||||
|
||||
fn read_body(stream: &mut impl Read, head: &Head) -> IdeResult<Vec<u8>> {
|
||||
Ok(if head.chunked {
|
||||
read_chunked(stream)?
|
||||
} else if let Some(n) = length {
|
||||
} else if let Some(n) = head.length {
|
||||
read_exact_n(stream, n)?
|
||||
} else {
|
||||
let mut body = Vec::new();
|
||||
stream.read_to_end(&mut body)?;
|
||||
body
|
||||
};
|
||||
Ok(Response { status, body })
|
||||
})
|
||||
}
|
||||
|
||||
/// Reads one `\n`-terminated line (returned without it).
|
||||
@@ -482,6 +500,292 @@ pub(crate) fn inspect(
|
||||
})())
|
||||
}
|
||||
|
||||
/// The processes running in a container (`docker top`).
|
||||
pub(crate) fn container_top(ep: &DockerEndpoint, id: &str, timeout: Duration) -> Option<IdeResult<DockerProcessList>> {
|
||||
let addr = address(ep)?;
|
||||
Some((|| {
|
||||
let body = check(request(&addr, "GET", &format!("/containers/{}/top", path_segment(id)), timeout)?)?;
|
||||
serde_json::from_str::<ApiTop>(&body)
|
||||
.map(|t| DockerProcessList { titles: t.titles, processes: t.processes })
|
||||
.map_err(|e| IdeError::internal(format!("the Docker daemon's process list is not JSON: {e}")))
|
||||
})())
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiTop {
|
||||
titles: Vec<String>,
|
||||
processes: Vec<Vec<String>>,
|
||||
}
|
||||
|
||||
/// An image's layers, newest first (`docker image history`).
|
||||
pub(crate) fn image_history(
|
||||
ep: &DockerEndpoint,
|
||||
id: &str,
|
||||
timeout: Duration,
|
||||
) -> Option<IdeResult<Vec<DockerImageLayer>>> {
|
||||
let addr = address(ep)?;
|
||||
Some((|| {
|
||||
let body = check(request(&addr, "GET", &format!("/images/{}/history", path_segment(id)), timeout)?)?;
|
||||
let layers = serde_json::from_str::<Vec<ApiLayer>>(&body)
|
||||
.map_err(|e| IdeError::internal(format!("the Docker daemon's image history is not JSON: {e}")))?;
|
||||
Ok(map_layers(layers, unix_now()))
|
||||
})())
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiLayer {
|
||||
id: String,
|
||||
created: i64,
|
||||
created_by: String,
|
||||
size: i64,
|
||||
comment: String,
|
||||
}
|
||||
|
||||
fn map_layers(layers: Vec<ApiLayer>, now: i64) -> Vec<DockerImageLayer> {
|
||||
layers
|
||||
.into_iter()
|
||||
.map(|l| DockerImageLayer {
|
||||
id: l.id,
|
||||
created_by: l.created_by,
|
||||
size: human_size(l.size),
|
||||
created_since: human_duration((now - l.created).max(0)),
|
||||
created_at: unix_utc(l.created),
|
||||
comment: l.comment,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn unix_now() -> i64 {
|
||||
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs() as i64).unwrap_or(0)
|
||||
}
|
||||
|
||||
/// How often a log stream that has nothing to read checks for cancellation.
|
||||
const LOG_POLL: Duration = Duration::from_millis(200);
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiContainerInspect {
|
||||
config: ApiContainerConfig,
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiContainerConfig {
|
||||
tty: bool,
|
||||
}
|
||||
|
||||
/// Streams a container's logs (`tail` last lines, then follows while `follow`)
|
||||
/// from `ep`'s daemon until they end or `cancel` fires.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(crate) fn logs(
|
||||
ep: &DockerEndpoint,
|
||||
id: &str,
|
||||
tail: u32,
|
||||
follow: bool,
|
||||
timestamps: bool,
|
||||
timeout: Duration,
|
||||
cancel: &CancellationToken,
|
||||
on_line: &dyn Fn(DockerLogLine),
|
||||
) -> Option<IdeResult<()>> {
|
||||
let addr = address(ep)?;
|
||||
Some((|| {
|
||||
// A TTY container's log is one raw stream; otherwise it is framed per stream.
|
||||
let body = check(request(&addr, "GET", &format!("/containers/{}/json", path_segment(id)), timeout)?)?;
|
||||
let tty = serde_json::from_str::<ApiContainerInspect>(&body).map(|c| c.config.tty).unwrap_or(false);
|
||||
let path = format!(
|
||||
"/containers/{}/logs?stdout=1&stderr=1&tail={tail}&follow={}×tamps={}",
|
||||
path_segment(id),
|
||||
u8::from(follow),
|
||||
u8::from(timestamps),
|
||||
);
|
||||
let mut conn = Conn::connect(&addr, timeout)?;
|
||||
conn.write_all(
|
||||
format!("GET {path} HTTP/1.1\r\nHost: docker\r\nUser-Agent: openidea\r\nConnection: close\r\n\r\n")
|
||||
.as_bytes(),
|
||||
)?;
|
||||
let head = read_head(&mut conn)?;
|
||||
if !(200..300).contains(&head.status) {
|
||||
let body = read_body(&mut conn, &head)?;
|
||||
check(Response { status: head.status, body })?;
|
||||
}
|
||||
conn.set_timeouts(LOG_POLL);
|
||||
let mut decoder = LogDecoder::new(&head, tty);
|
||||
let mut buf = [0u8; 8192];
|
||||
while !decoder.done() {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
match conn.read(&mut buf) {
|
||||
Ok(0) => break,
|
||||
Ok(n) => decoder.feed(&buf[..n], &mut |line| on_line(line))?,
|
||||
Err(e)
|
||||
if matches!(
|
||||
e.kind(),
|
||||
std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut | std::io::ErrorKind::Interrupted
|
||||
) => {}
|
||||
Err(e) => return Err(e.into()),
|
||||
}
|
||||
}
|
||||
decoder.finish(&mut |line| on_line(line));
|
||||
Ok(())
|
||||
})())
|
||||
}
|
||||
|
||||
/// Turns a log response body, as it arrives, into lines: undoes the chunked
|
||||
/// transfer encoding, then the per-stream frames (8-byte header: stream, 3 zero
|
||||
/// bytes, big-endian length) unless the container has a TTY.
|
||||
struct LogDecoder {
|
||||
body: BodyFraming,
|
||||
tty: bool,
|
||||
header: Vec<u8>,
|
||||
frame_left: usize,
|
||||
frame_stderr: bool,
|
||||
/// Partial lines of stdout and stderr.
|
||||
partial: [Vec<u8>; 2],
|
||||
}
|
||||
|
||||
enum BodyFraming {
|
||||
Chunked { state: ChunkState, line: Vec<u8> },
|
||||
Length(usize),
|
||||
Close,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
enum ChunkState {
|
||||
Size,
|
||||
Data(usize),
|
||||
DataEnd,
|
||||
Trailer,
|
||||
Done,
|
||||
}
|
||||
|
||||
impl LogDecoder {
|
||||
fn new(head: &Head, tty: bool) -> Self {
|
||||
let body = if head.chunked {
|
||||
BodyFraming::Chunked { state: ChunkState::Size, line: Vec::new() }
|
||||
} else if let Some(n) = head.length {
|
||||
BodyFraming::Length(n)
|
||||
} else {
|
||||
BodyFraming::Close
|
||||
};
|
||||
Self { body, tty, header: Vec::new(), frame_left: 0, frame_stderr: false, partial: [Vec::new(), Vec::new()] }
|
||||
}
|
||||
|
||||
fn done(&self) -> bool {
|
||||
matches!(self.body, BodyFraming::Chunked { state: ChunkState::Done, .. } | BodyFraming::Length(0))
|
||||
}
|
||||
|
||||
fn feed(&mut self, mut bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) -> IdeResult<()> {
|
||||
let mut payload = Vec::new();
|
||||
match &mut self.body {
|
||||
BodyFraming::Close => payload.extend_from_slice(bytes),
|
||||
BodyFraming::Length(left) => {
|
||||
let take = (*left).min(bytes.len());
|
||||
payload.extend_from_slice(&bytes[..take]);
|
||||
*left -= take;
|
||||
}
|
||||
BodyFraming::Chunked { state, line } => {
|
||||
while !bytes.is_empty() {
|
||||
match *state {
|
||||
ChunkState::Done => break,
|
||||
ChunkState::Data(n) => {
|
||||
let take = n.min(bytes.len());
|
||||
payload.extend_from_slice(&bytes[..take]);
|
||||
bytes = &bytes[take..];
|
||||
*state = if take == n { ChunkState::DataEnd } else { ChunkState::Data(n - take) };
|
||||
}
|
||||
_ => {
|
||||
let b = bytes[0];
|
||||
bytes = &bytes[1..];
|
||||
if b != b'\n' {
|
||||
if b != b'\r' {
|
||||
line.push(b);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let text = String::from_utf8_lossy(line).into_owned();
|
||||
line.clear();
|
||||
*state = match *state {
|
||||
ChunkState::Size => {
|
||||
let size = text.split(';').next().unwrap_or_default().trim();
|
||||
match usize::from_str_radix(size, 16) {
|
||||
Ok(0) => ChunkState::Trailer,
|
||||
Ok(n) => ChunkState::Data(n),
|
||||
Err(_) => {
|
||||
return Err(IdeError::internal(
|
||||
"the Docker daemon answered with a malformed chunked response",
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
ChunkState::DataEnd => ChunkState::Size,
|
||||
_ if text.is_empty() => ChunkState::Done,
|
||||
other => other,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
self.frames(&payload, emit);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn frames(&mut self, mut bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) {
|
||||
if self.tty {
|
||||
self.lines(false, bytes, emit);
|
||||
return;
|
||||
}
|
||||
while !bytes.is_empty() {
|
||||
if self.frame_left == 0 {
|
||||
let take = (8 - self.header.len()).min(bytes.len());
|
||||
self.header.extend_from_slice(&bytes[..take]);
|
||||
bytes = &bytes[take..];
|
||||
if self.header.len() == 8 {
|
||||
self.frame_stderr = self.header[0] == 2;
|
||||
self.frame_left =
|
||||
u32::from_be_bytes([self.header[4], self.header[5], self.header[6], self.header[7]]) as usize;
|
||||
self.header.clear();
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let take = self.frame_left.min(bytes.len());
|
||||
self.lines(self.frame_stderr, &bytes[..take], emit);
|
||||
self.frame_left -= take;
|
||||
bytes = &bytes[take..];
|
||||
}
|
||||
}
|
||||
|
||||
fn lines(&mut self, stderr: bool, bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) {
|
||||
let partial = &mut self.partial[usize::from(stderr)];
|
||||
for &b in bytes {
|
||||
if b == b'\n' {
|
||||
emit(DockerLogLine { stderr, text: line_text(partial) });
|
||||
partial.clear();
|
||||
} else {
|
||||
partial.push(b);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Emits the last lines that ended without a newline.
|
||||
fn finish(&mut self, emit: &mut dyn FnMut(DockerLogLine)) {
|
||||
for stderr in [false, true] {
|
||||
let partial = &mut self.partial[usize::from(stderr)];
|
||||
if !partial.is_empty() {
|
||||
emit(DockerLogLine { stderr, text: line_text(partial) });
|
||||
partial.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn line_text(bytes: &[u8]) -> String {
|
||||
String::from_utf8_lossy(bytes.strip_suffix(b"\r").unwrap_or(bytes)).into_owned()
|
||||
}
|
||||
|
||||
/// One URL path segment, percent-encoded so an id cannot change the path.
|
||||
fn path_segment(id: &str) -> String {
|
||||
let mut out = String::with_capacity(id.len());
|
||||
@@ -817,6 +1121,75 @@ mod tests {
|
||||
assert!(read_response(&mut &garbage[..]).is_err());
|
||||
}
|
||||
|
||||
/// Feeds `body` one byte at a time, as a slow connection delivers it.
|
||||
fn decode(head: Head, tty: bool, body: &[u8]) -> (Vec<(bool, String)>, bool) {
|
||||
let mut lines = Vec::new();
|
||||
let mut decoder = LogDecoder::new(&head, tty);
|
||||
for b in body {
|
||||
decoder.feed(std::slice::from_ref(b), &mut |l| lines.push((l.stderr, l.text))).unwrap();
|
||||
}
|
||||
let done = decoder.done();
|
||||
decoder.finish(&mut |l| lines.push((l.stderr, l.text)));
|
||||
(lines, done)
|
||||
}
|
||||
|
||||
fn frame(stream: u8, text: &str) -> Vec<u8> {
|
||||
let mut f = vec![stream, 0, 0, 0];
|
||||
f.extend((text.len() as u32).to_be_bytes());
|
||||
f.extend(text.as_bytes());
|
||||
f
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn engine_image_history_reads_like_the_cli() {
|
||||
let layers: Vec<ApiLayer> = serde_json::from_str(
|
||||
r#"[{"Id":"sha256:abc","Created":1000,"CreatedBy":"CMD [\"python3\"]","Size":20500,"Comment":"buildkit","Tags":["py:3"]},
|
||||
{"Id":"<missing>","Created":940,"CreatedBy":"RUN x","Size":0,"Comment":""}]"#,
|
||||
)
|
||||
.unwrap();
|
||||
let rows = map_layers(layers, 1000 + 2 * 7 * 86_400);
|
||||
assert_eq!(
|
||||
rows.iter().map(|l| (l.id.as_str(), l.size.as_str(), l.created_since.as_str())).collect::<Vec<_>>(),
|
||||
[("sha256:abc", "20.5kB", "2 weeks ago"), ("<missing>", "0B", "2 weeks ago")]
|
||||
);
|
||||
assert_eq!(rows[0].created_by, "CMD [\"python3\"]");
|
||||
let top: ApiTop = serde_json::from_str(r#"{"Titles":["PID","CMD"],"Processes":[["1","sh"]]}"#).unwrap();
|
||||
assert_eq!(
|
||||
(top.titles, top.processes),
|
||||
(vec!["PID".to_owned(), "CMD".to_owned()], vec![vec!["1".to_owned(), "sh".to_owned()]])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn container_logs_split_into_stream_lines_across_chunks_and_frames() {
|
||||
// Frames split mid-line, a CRLF line, and a stderr line between stdout parts.
|
||||
let mut framed = frame(1, "tick 1\r\ntick");
|
||||
framed.extend(frame(2, "oops\n"));
|
||||
framed.extend(frame(1, " 2\nlast"));
|
||||
let mut chunked = Vec::new();
|
||||
for part in framed.chunks(7) {
|
||||
chunked.extend(format!("{:x}\r\n", part.len()).as_bytes());
|
||||
chunked.extend(part);
|
||||
chunked.extend(b"\r\n");
|
||||
}
|
||||
chunked.extend(b"0\r\n\r\n");
|
||||
let (lines, done) = decode(Head { status: 200, chunked: true, length: None }, false, &chunked);
|
||||
assert!(done);
|
||||
let expected = [(false, "tick 1"), (true, "oops"), (false, "tick 2"), (false, "last")];
|
||||
assert_eq!(lines, expected.map(|(e, t)| (e, t.to_owned())));
|
||||
|
||||
// A TTY container's log is one raw stream; the body may end with the connection.
|
||||
let (lines, done) = decode(Head { status: 200, chunked: false, length: None }, true, b"a\r\nb\n");
|
||||
assert!(!done);
|
||||
assert_eq!(lines, [(false, "a".to_owned()), (false, "b".to_owned())]);
|
||||
|
||||
// A Content-Length body ends after its length.
|
||||
let body = frame(1, "one\n");
|
||||
let (lines, done) = decode(Head { status: 200, chunked: false, length: Some(body.len()) }, false, &body);
|
||||
assert!(done);
|
||||
assert_eq!(lines, [(false, "one".to_owned())]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn daemon_errors_carry_their_message() {
|
||||
let resp = Response { status: 404, body: br#"{"message":"No such container: missing"}"#.to_vec() };
|
||||
|
||||
@@ -287,6 +287,11 @@ fn check_id(id: &str) -> IdeResult<&str> {
|
||||
/// `docker image history --no-trunc --format '{{json .}}'` of one image.
|
||||
pub fn image_history(ep: &DockerEndpoint, id: &str) -> IdeResult<Vec<DockerImageLayer>> {
|
||||
let id = check_id(id)?;
|
||||
if docker_executable().is_none()
|
||||
&& let Some(layers) = engine::image_history(ep, id, QUICK)
|
||||
{
|
||||
return layers;
|
||||
}
|
||||
let out = run(ep, &["image", "history", "--no-trunc", "--format", "{{json .}}", id], QUICK)?;
|
||||
Ok(parse_image_history(&out))
|
||||
}
|
||||
@@ -294,6 +299,11 @@ pub fn image_history(ep: &DockerEndpoint, id: &str) -> IdeResult<Vec<DockerImage
|
||||
/// `docker top <id>` of a running container.
|
||||
pub fn container_top(ep: &DockerEndpoint, id: &str) -> IdeResult<DockerProcessList> {
|
||||
let id = check_id(id)?;
|
||||
if docker_executable().is_none()
|
||||
&& let Some(processes) = engine::container_top(ep, id, QUICK)
|
||||
{
|
||||
return processes;
|
||||
}
|
||||
let out = run(ep, &["top", id], QUICK)?;
|
||||
Ok(parse_container_top(&out))
|
||||
}
|
||||
@@ -316,6 +326,11 @@ pub fn logs(
|
||||
cancel: &CancellationToken,
|
||||
on_line: &dyn Fn(DockerLogLine),
|
||||
) -> IdeResult<()> {
|
||||
if docker_executable().is_none()
|
||||
&& let Some(streamed) = engine::logs(ep, id, tail, follow, timestamps, QUICK, cancel, on_line)
|
||||
{
|
||||
return streamed;
|
||||
}
|
||||
let tail = tail.to_string();
|
||||
let mut args = vec!["logs", "--tail", &tail];
|
||||
if follow {
|
||||
|
||||
@@ -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,
|
||||
);
|
||||
@@ -8,30 +8,79 @@ use crate::{Host, Project};
|
||||
use ide_command::command;
|
||||
|
||||
use ide_build::compile::{self, BuildEvent, BuildKind, BuildResult};
|
||||
use ide_build::maven::PomGoto;
|
||||
use ide_build::maven::completion::{PomCompletion, PomCompletionOption};
|
||||
use ide_build::maven::{PomGoto, PomManagedDeclaration, PomNavigationOptions};
|
||||
use ide_build::pom_edit::{ArtifactKey, Exclusion};
|
||||
use ide_build::{BuildModel, BuildTool, SyncOptions, SyncProgress};
|
||||
use ide_core::settings::Settings;
|
||||
use ide_core::{DocId, FileEdit, IdeError, IdeEvent, IdeResult, Location, Pos, Range, RequestId, WorkspaceEdit};
|
||||
use std::collections::HashMap;
|
||||
use std::path::Path;
|
||||
use std::sync::Arc;
|
||||
use std::sync::{Arc, Mutex, OnceLock};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
fn join_err(e: tokio::task::JoinError) -> IdeError {
|
||||
IdeError::internal(e.to_string())
|
||||
}
|
||||
|
||||
/// POM gutters in several editors refresh together. A very short cache lets those
|
||||
/// requests share one reactor scan without serving a stale module list after edits settle.
|
||||
const MAVEN_MODULE_CACHE_TTL: Duration = Duration::from_millis(250);
|
||||
type MavenModuleCache = HashMap<String, (Instant, Vec<ide_build::maven::ModulePom>)>;
|
||||
static MAVEN_MODULES: OnceLock<Mutex<MavenModuleCache>> = OnceLock::new();
|
||||
|
||||
fn maven_modules(
|
||||
project: &Project,
|
||||
settings: &Settings,
|
||||
options: &PomNavigationOptions,
|
||||
) -> Vec<ide_build::maven::ModulePom> {
|
||||
let key = format!(
|
||||
"{}\0{:?}\0{:?}\0{:?}\0{:?}",
|
||||
project.root.display(),
|
||||
project.build_cache_dir(),
|
||||
settings.languages.java.maven.linked_projects,
|
||||
options.profiles,
|
||||
options.jdk_version
|
||||
);
|
||||
let cache = MAVEN_MODULES.get_or_init(|| Mutex::new(HashMap::new()));
|
||||
if let Some((_at, modules)) = cache.lock().ok().and_then(|mut cache| {
|
||||
let fresh = cache.get(&key).filter(|(at, _)| at.elapsed() < MAVEN_MODULE_CACHE_TTL).cloned();
|
||||
if fresh.is_none() {
|
||||
cache.remove(&key);
|
||||
}
|
||||
fresh
|
||||
}) {
|
||||
return modules;
|
||||
}
|
||||
let model = load(&project.root, &project.build_cache_dir(), settings).maven.unwrap_or_default();
|
||||
let modules = model
|
||||
.projects
|
||||
.into_iter()
|
||||
.map(|p| ide_build::maven::ModulePom {
|
||||
group_id: p.group_id,
|
||||
artifact_id: p.artifact_id,
|
||||
version: p.version,
|
||||
pom: project.root.join(&p.pom),
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
if let Ok(mut cache) = cache.lock() {
|
||||
cache.insert(key, (Instant::now(), modules.clone()));
|
||||
}
|
||||
modules
|
||||
}
|
||||
|
||||
/// The build model with the launch settings applied: the JDK (`JAVA_HOME`), and
|
||||
/// the Maven home and options from Settings › Maven.
|
||||
pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
|
||||
let mut model = ide_build::load_linked(
|
||||
let jdk = ide_sdk::apply::project_jdk(root, settings);
|
||||
let mut model = ide_build::load_linked_with_jdk(
|
||||
root,
|
||||
cache,
|
||||
ide_sdk::apply::maven_local_repository(root, settings),
|
||||
&settings.languages.java.maven,
|
||||
&settings.languages.java.gradle,
|
||||
ide_sdk::apply::maven_jdk(root, settings, None).map(|jdk| jdk.major),
|
||||
);
|
||||
let jdk = ide_sdk::apply::project_jdk(root, settings);
|
||||
if let Some(m) = &mut model.maven {
|
||||
let mvn = ide_sdk::apply::maven_command(root, settings);
|
||||
let options = ide_sdk::apply::maven_options(root, settings);
|
||||
@@ -77,6 +126,23 @@ pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
|
||||
model
|
||||
}
|
||||
|
||||
/// POM navigation follows the same profile choices as the last Maven sync and
|
||||
/// resolves JDK-activated profiles with the project's selected Maven runtime.
|
||||
fn pom_navigation_options(project: &Project, settings: &Settings) -> PomNavigationOptions {
|
||||
let mut profiles = settings.languages.java.maven.profiles(&[]);
|
||||
for profile in ide_build::maven_profiles(&project.build_cache_dir()) {
|
||||
if !profiles.contains(&profile) {
|
||||
profiles.push(profile);
|
||||
}
|
||||
}
|
||||
PomNavigationOptions {
|
||||
local_repo: ide_sdk::apply::maven_local_repository(&project.root, settings)
|
||||
.or_else(ide_build::maven::default_local_repo),
|
||||
profiles,
|
||||
jdk_version: ide_sdk::apply::maven_jdk(&project.root, settings, None).map(|jdk| jdk.major),
|
||||
}
|
||||
}
|
||||
|
||||
/// Build and Run use the same selected toolchain and module-local runtime discovery.
|
||||
fn prepare_plan(mut plan: compile::BuildPlan, root: &Path, settings: &Settings) -> compile::BuildPlan {
|
||||
let kind = match plan.system {
|
||||
@@ -547,8 +613,9 @@ pub async fn maven_dependency_declaration(
|
||||
}
|
||||
|
||||
/// The go-to-declaration target at `pos` of a Maven POM: the definition of the
|
||||
/// `${property}` at the caret, or the `<dependencyManagement>` / `<pluginManagement>`
|
||||
/// entry providing the dependency's / plugin's version, along the parent chain.
|
||||
/// `${property}` at the caret, the parent POM, or the dependency / plugin's own POM
|
||||
/// (a project module first, then the local repository). A dependency without a
|
||||
/// resolvable artifact POM falls back to its management entry.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos: Pos) -> IdeResult<Option<PomGoto>> {
|
||||
// `pom` is project-relative, or absolute for a parent POM opened from the local repository.
|
||||
@@ -561,26 +628,55 @@ pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos:
|
||||
let path = if given.is_absolute() { given.to_path_buf() } else { project.root.join(given) };
|
||||
let text = project.text_of(&path)?;
|
||||
let settings = project.settings.effective();
|
||||
let repo = ide_sdk::apply::maven_local_repository(&project.root, &settings)
|
||||
.or_else(ide_build::maven::default_local_repo);
|
||||
let modules = || {
|
||||
let model = load(&project.root, &project.build_cache_dir(), &settings).maven.unwrap_or_default();
|
||||
model
|
||||
.projects
|
||||
.into_iter()
|
||||
.map(|p| ide_build::maven::ModulePom {
|
||||
group_id: p.group_id,
|
||||
artifact_id: p.artifact_id,
|
||||
pom: project.root.join(&p.pom),
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
Ok(ide_build::maven::goto_declaration_in(&text, &path, pos, repo, modules))
|
||||
let options = pom_navigation_options(&project, &settings);
|
||||
let module_options = options.clone();
|
||||
let modules = || maven_modules(&project, &settings, &module_options);
|
||||
Ok(ide_build::maven::goto_declaration_with(&text, &path, pos, options, modules))
|
||||
})
|
||||
.await
|
||||
.map_err(join_err)?
|
||||
}
|
||||
|
||||
/// Gutter targets of the unversioned dependencies and plugins in a Maven POM:
|
||||
/// the management declarations that actually supply their versions, including
|
||||
/// parent POMs and imported BOMs. Cancel with `cancel_request(request)`.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn maven_managed_declarations(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
pom: String,
|
||||
request: RequestId,
|
||||
) -> IdeResult<Vec<PomManagedDeclaration>> {
|
||||
let project = host.project(window)?;
|
||||
let cancel = host.begin_project_read_request(window, request);
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let given = Path::new(&pom);
|
||||
let path = if given.is_absolute() { given.to_path_buf() } else { project.root.join(given) };
|
||||
let text = project.text_of(&path)?;
|
||||
let settings = project.settings.effective();
|
||||
let options = pom_navigation_options(&project, &settings);
|
||||
let cancelled = cancel.clone();
|
||||
let module_options = options.clone();
|
||||
let modules = || {
|
||||
if cancelled.is_cancelled() {
|
||||
return Vec::new();
|
||||
}
|
||||
maven_modules(&project, &settings, &module_options)
|
||||
};
|
||||
let declarations = ide_build::maven::managed_declarations_with(&text, &path, options, modules);
|
||||
if cancel.is_cancelled() { Err(IdeError::cancelled()) } else { Ok(declarations) }
|
||||
})
|
||||
.await;
|
||||
host.end_request(request);
|
||||
match result {
|
||||
Ok(result) => result,
|
||||
Err(error) => Err(join_err(error)),
|
||||
}
|
||||
}
|
||||
|
||||
/// How long completion waits for Maven Central before answering from the local repository.
|
||||
const CENTRAL_WAIT: std::time::Duration = std::time::Duration::from_secs(1);
|
||||
|
||||
@@ -1333,4 +1429,5 @@ ide_command::domain!(
|
||||
maven_dependency_declaration,
|
||||
maven_exclude_dependency,
|
||||
maven_goto_declaration,
|
||||
maven_managed_declarations,
|
||||
);
|
||||
@@ -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() {
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -1112,8 +1112,12 @@ fn module_count(root: &Path) -> usize {
|
||||
/// named after its `artifactId` (usually its folder), a Gradle one `<project>.<path>.<source set>`.
|
||||
fn module_dir(root: &Path, name: &str) -> Option<String> {
|
||||
let folder = |dir: &Path| dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
|
||||
let exact = |dir: &Path| folder(dir) == name || pom_artifact(dir).is_some_and(|a| a == name);
|
||||
if let Some(dir) = find_module(root, &exact) {
|
||||
// A Maven module is named after its artifactId, so that match wins over a folder of the same
|
||||
// name anywhere above it (a checkout folder named like a child module's artifactId).
|
||||
if let Some(dir) = find_module(root, &|dir: &Path| pom_artifact(dir).is_some_and(|a| a == name)) {
|
||||
return Some(dir);
|
||||
}
|
||||
if let Some(dir) = find_module(root, &|dir: &Path| folder(dir) == name) {
|
||||
return Some(dir);
|
||||
}
|
||||
let gradle = name.strip_suffix(".main").or_else(|| name.strip_suffix(".test")).unwrap_or(name);
|
||||
|
||||
@@ -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| {
|
||||
|
||||
@@ -860,6 +860,38 @@ fn java_applications_and_spring_boot_keep_their_module() {
|
||||
assert_eq!(reason(&r, "NoMain"), &SkipReason::NothingToRun);
|
||||
}
|
||||
|
||||
/// A checkout folder named like a child module's artifactId: IDEA's module is the child.
|
||||
#[test]
|
||||
fn maven_module_artifact_wins_over_a_folder_of_the_same_name() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(dir.path()).unwrap().join("demo-service");
|
||||
write(
|
||||
&root,
|
||||
"pom.xml",
|
||||
"<project><artifactId>demo-service-parent</artifactId><packaging>pom</packaging></project>",
|
||||
);
|
||||
write(
|
||||
&root,
|
||||
"app-web/pom.xml",
|
||||
"<project><parent><artifactId>demo-service-parent</artifactId></parent><artifactId>demo-service</artifactId></project>",
|
||||
);
|
||||
write(
|
||||
&root,
|
||||
".run/Demo.run.xml",
|
||||
&run_file(
|
||||
"Demo",
|
||||
r#"<configuration name="Demo" type="Application" factoryName="Application">
|
||||
<module name="demo-service" />
|
||||
<option name="MAIN_CLASS_NAME" value="com.example.Demo" />
|
||||
</configuration>"#,
|
||||
),
|
||||
);
|
||||
|
||||
let r = import_from(&root, &[]);
|
||||
|
||||
assert_eq!(get(&r, "Demo").extras.module.as_deref(), Some("app-web"));
|
||||
}
|
||||
|
||||
/// IDEA writes the working directory as a URL. On Windows `file://$PROJECT_DIR$`
|
||||
/// expands to `file://C:/project`, where the drive letter sits where the authority
|
||||
/// belongs; read as a path that is `C:project`, which resolves against the project
|
||||
|
||||
@@ -84,7 +84,7 @@ pub fn project_libraries_stream(
|
||||
cancel: &CancellationToken,
|
||||
on_groups: &(dyn Fn(Vec<LibraryGroup>) + Sync),
|
||||
) -> Vec<LibraryGroup> {
|
||||
type Detect = fn(&Path, &Settings, &CancellationToken) -> Vec<LibraryGroup>;
|
||||
type Detect = fn(&Path, &Path, &Settings, &CancellationToken) -> Vec<LibraryGroup>;
|
||||
let detectors: [Detect; 6] = [python_groups, jdk_groups, node_groups, go_groups, ruby_groups, zig_groups];
|
||||
let roots = library_project_roots(root, cancel);
|
||||
let settings = module_settings(root, settings);
|
||||
@@ -99,7 +99,7 @@ pub fn project_libraries_stream(
|
||||
if cancel.is_cancelled() {
|
||||
break;
|
||||
}
|
||||
let batch = d(dir, settings, cancel);
|
||||
let batch = d(dir, root, settings, cancel);
|
||||
if !cancel.is_cancelled() && !batch.is_empty() {
|
||||
on_groups(batch.clone());
|
||||
groups.extend(batch);
|
||||
@@ -384,7 +384,7 @@ fn tool(bin: Option<PathBuf>, name: &str) -> Option<PathBuf> {
|
||||
|
||||
// ------------------------------------------------------------------ python
|
||||
|
||||
fn python_groups(root: &Path, s: &Settings, cancel: &CancellationToken) -> Vec<LibraryGroup> {
|
||||
fn python_groups(root: &Path, _project: &Path, s: &Settings, cancel: &CancellationToken) -> Vec<LibraryGroup> {
|
||||
let Some(python) = crate::apply::python_interpreter(root, s) else { return Vec::new() };
|
||||
let mut files = vec![python.clone()];
|
||||
files.extend(crate::venv_of(&python).map(|v| v.join("pyvenv.cfg")));
|
||||
@@ -436,7 +436,7 @@ pub(crate) fn named_roots(roots: Vec<(String, PathBuf)>) -> Vec<LibraryRoot> {
|
||||
|
||||
// ------------------------------------------------------------------ ruby
|
||||
|
||||
fn ruby_groups(root: &Path, s: &Settings, cancel: &CancellationToken) -> Vec<LibraryGroup> {
|
||||
fn ruby_groups(root: &Path, _project: &Path, s: &Settings, cancel: &CancellationToken) -> Vec<LibraryGroup> {
|
||||
let Some(files) = manifests(root, RUBY_MANIFESTS) else { return Vec::new() };
|
||||
if !root.join("Gemfile").is_file() && !root.join(".ruby-version").is_file() {
|
||||
return Vec::new();
|
||||
@@ -454,7 +454,7 @@ fn ruby_groups(root: &Path, s: &Settings, cancel: &CancellationToken) -> Vec<Lib
|
||||
|
||||
// ------------------------------------------------------------------ jdk
|
||||
|
||||
fn jdk_groups(root: &Path, s: &Settings, cancel: &CancellationToken) -> Vec<LibraryGroup> {
|
||||
fn jdk_groups(root: &Path, _project: &Path, s: &Settings, cancel: &CancellationToken) -> Vec<LibraryGroup> {
|
||||
// Java modules without a build manifest carry `.classpath` / `.project` /
|
||||
// `.idea` instead; a configured JDK or declared source roots mark one too.
|
||||
let files = match manifests(root, JAVA_MANIFESTS) {
|
||||
@@ -731,7 +731,7 @@ pub(crate) fn gradle_jar(home: &Path, d: &BuildDependency) -> Option<PathBuf> {
|
||||
|
||||
// ------------------------------------------------------------------ node
|
||||
|
||||
fn node_groups(root: &Path, s: &Settings, _cancel: &CancellationToken) -> Vec<LibraryGroup> {
|
||||
fn node_groups(root: &Path, _project: &Path, s: &Settings, _cancel: &CancellationToken) -> Vec<LibraryGroup> {
|
||||
if !root.join("package.json").is_file() {
|
||||
return Vec::new();
|
||||
}
|
||||
@@ -907,7 +907,7 @@ pub(crate) fn parse_cargo_metadata(json: &str) -> Option<Vec<(String, PathBuf)>>
|
||||
|
||||
// ------------------------------------------------------------------ go
|
||||
|
||||
fn go_groups(root: &Path, s: &Settings, cancel: &CancellationToken) -> Vec<LibraryGroup> {
|
||||
fn go_groups(root: &Path, project: &Path, s: &Settings, cancel: &CancellationToken) -> Vec<LibraryGroup> {
|
||||
let Some(mut files) = manifests(root, GO_MANIFESTS) else { return Vec::new() };
|
||||
if !root.join("go.mod").is_file() && !root.join("go.work").is_file() {
|
||||
return Vec::new();
|
||||
@@ -958,7 +958,7 @@ fn go_groups(root: &Path, s: &Settings, cancel: &CancellationToken) -> Vec<Libra
|
||||
} else if let Some(text) =
|
||||
query_in_cancellable(&go, &["list", "-m", "-e", "-json", "all"], root, &env, GRAPH_TIMEOUT, cancel)
|
||||
{
|
||||
out.extend(group("Go Modules", "goModules", named_roots(parse_go_modules(&text))));
|
||||
out.extend(group("Go Modules", "goModules", named_roots(parse_go_modules(&text, project))));
|
||||
}
|
||||
out
|
||||
})
|
||||
@@ -978,8 +978,19 @@ fn vendor_roots(vendor: &Path, text: &str) -> Vec<(String, PathBuf)> {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// `(path@version, dir)` of the downloaded non-main modules in `go list -m -json` output.
|
||||
pub(crate) fn parse_go_modules(text: &str) -> Vec<(String, PathBuf)> {
|
||||
/// True when `path` is source the user owns: inside `project` and not a `vendor` copy.
|
||||
fn is_project_source(project: &Path, path: &Path) -> bool {
|
||||
let project = project.canonicalize().unwrap_or_else(|_| project.to_path_buf());
|
||||
let path = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
|
||||
let Ok(relative) = path.strip_prefix(&project) else { return false };
|
||||
!relative.components().any(|component| component.as_os_str() == "vendor")
|
||||
}
|
||||
|
||||
/// `(path@version, dir)` of the modules that are libraries: everything whose source is
|
||||
/// outside the opened project. Source inside it is the user's own code — the target of a
|
||||
/// `replace`, say — and stays editable; a `vendor` copy is the exception, checked in and
|
||||
/// kept read-only.
|
||||
pub(crate) fn parse_go_modules(text: &str, project: &Path) -> Vec<(String, PathBuf)> {
|
||||
#[derive(Deserialize)]
|
||||
#[serde(rename_all = "PascalCase")]
|
||||
struct Module {
|
||||
@@ -993,6 +1004,8 @@ pub(crate) fn parse_go_modules(text: &str) -> Vec<(String, PathBuf)> {
|
||||
.into_iter::<Module>()
|
||||
.map_while(Result::ok)
|
||||
.filter(|m| !m.main)
|
||||
// A module whose source sits in the project is the user's own code, not a library.
|
||||
.filter(|m| m.dir.as_deref().is_none_or(|dir| !is_project_source(project, dir)))
|
||||
.filter_map(|m| {
|
||||
let name = match &m.version {
|
||||
Some(v) => format!("{}@{v}", m.path),
|
||||
@@ -1005,7 +1018,7 @@ pub(crate) fn parse_go_modules(text: &str) -> Vec<(String, PathBuf)> {
|
||||
|
||||
// ------------------------------------------------------------------ zig
|
||||
|
||||
fn zig_groups(root: &Path, s: &Settings, cancel: &CancellationToken) -> Vec<LibraryGroup> {
|
||||
fn zig_groups(root: &Path, _project: &Path, s: &Settings, cancel: &CancellationToken) -> Vec<LibraryGroup> {
|
||||
let Some(files) = manifests(root, ZIG_MANIFESTS) else { return Vec::new() };
|
||||
let Some(zig) = tool(crate::apply::zig_bin(root, s), "zig") else { return Vec::new() };
|
||||
cached_cancellable(root, "zig", zig.display().to_string(), &files, cancel, || {
|
||||
@@ -1574,7 +1587,7 @@ mod zig_tests {
|
||||
std::fs::set_permissions(&zig, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
let mut settings = Settings::default();
|
||||
settings.languages.zig.zig = "tools".into();
|
||||
let groups = zig_groups(root, &settings, &CancellationToken::new());
|
||||
let groups = zig_groups(root, root, &settings, &CancellationToken::new());
|
||||
let summary: Vec<(&str, &str, Vec<&str>)> = groups
|
||||
.iter()
|
||||
.map(|g| (g.name.as_str(), g.kind.as_str(), g.roots.iter().map(|r| r.name.as_str()).collect()))
|
||||
|
||||
@@ -1875,7 +1875,7 @@ fn go_modules_skip_the_main_module_and_missing_downloads() {
|
||||
{"Path":"golang.org/x/text","Version":"v0.14.0","Dir":"/gopath/pkg/mod/golang.org/x/[email protected]"}
|
||||
{"Path":"example.com/missing","Version":"v1.0.0","Error":{"Err":"module lookup disabled"}}"#;
|
||||
assert_eq!(
|
||||
crate::libraries::parse_go_modules(out),
|
||||
crate::libraries::parse_go_modules(out, std::path::Path::new("/p")),
|
||||
[(
|
||||
"golang.org/x/[email protected]".to_owned(),
|
||||
std::path::PathBuf::from("/gopath/pkg/mod/golang.org/x/[email protected]")
|
||||
@@ -1883,6 +1883,35 @@ fn go_modules_skip_the_main_module_and_missing_downloads() {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn go_modules_skip_module_sources_inside_the_project() {
|
||||
let out = r#"{"Path":"example.com/app","Main":true,"Dir":"/p/app"}
|
||||
{"Path":"example.com/local","Version":"v0.0.0","Dir":"/p/local"}
|
||||
{"Path":"example.com/vendored","Version":"v0.0.0","Dir":"/p/vendor/vendored"}
|
||||
{"Path":"example.com/outside","Version":"v1.0.0","Dir":"/other/outside"}
|
||||
{"Path":"golang.org/x/text","Version":"v0.14.0","Dir":"/gopath/pkg/mod/golang.org/x/[email protected]"}"#;
|
||||
assert_eq!(
|
||||
crate::libraries::parse_go_modules(out, std::path::Path::new("/p")),
|
||||
[
|
||||
("example.com/[email protected]".to_owned(), std::path::PathBuf::from("/p/vendor/vendored")),
|
||||
("example.com/[email protected]".to_owned(), std::path::PathBuf::from("/other/outside")),
|
||||
(
|
||||
"golang.org/x/[email protected]".to_owned(),
|
||||
std::path::PathBuf::from("/gopath/pkg/mod/golang.org/x/[email protected]")
|
||||
),
|
||||
]
|
||||
);
|
||||
// Opened from a root that does not contain it: the same folder is a library again.
|
||||
assert!(
|
||||
crate::libraries::parse_go_modules(
|
||||
r#"{"Path":"example.com/local","Version":"v0.0.0","Dir":"/p/local"}"#,
|
||||
std::path::Path::new("/p/app")
|
||||
)
|
||||
.iter()
|
||||
.any(|(name, _)| name == "example.com/[email protected]")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn build_zig_zon_dependencies_are_parsed() {
|
||||
let zon = r#"// the manifest is a Zig struct literal
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -19,6 +19,9 @@ 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,
|
||||
@@ -269,7 +272,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)
|
||||
|
||||
@@ -22,6 +22,7 @@ parking_lot.workspace = true
|
||||
zip.workspace = true
|
||||
flate2.workspace = true
|
||||
tar.workspace = true
|
||||
rayon.workspace = true
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile.workspace = true
|
||||
|
||||
@@ -10,6 +10,7 @@ mod rules;
|
||||
mod watch;
|
||||
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use rayon::prelude::*;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::cmp::Ordering;
|
||||
@@ -133,51 +134,57 @@ pub fn read_dir(dir: &Path, excludes: &[String]) -> IdeResult<Vec<FileEntry>> {
|
||||
let base = gitignore.repo_root().unwrap_or(dir).to_path_buf();
|
||||
let excludes = ExcludeMatcher::new(excludes);
|
||||
|
||||
let mut entries: Vec<(bool, FileEntry)> = Vec::new();
|
||||
for entry in fs::read_dir(dir)? {
|
||||
let entry = match entry {
|
||||
Ok(e) => e,
|
||||
let paths: Vec<PathBuf> = fs::read_dir(dir)?
|
||||
.filter_map(|entry| match entry {
|
||||
Ok(e) => Some(e.path()),
|
||||
Err(e) => {
|
||||
tracing::debug!("read_dir {}: {e}", dir.display());
|
||||
continue;
|
||||
None
|
||||
}
|
||||
};
|
||||
let path = entry.path();
|
||||
let name = entry.file_name().to_string_lossy().into_owned();
|
||||
let Ok(lmeta) = fs::symlink_metadata(&path) else { continue };
|
||||
let (kind, meta, target_kind) = if lmeta.file_type().is_symlink() {
|
||||
match fs::metadata(&path) {
|
||||
Ok(m) => {
|
||||
let target = if m.is_dir() { EntryKind::Dir } else { EntryKind::File };
|
||||
(EntryKind::Symlink, m, Some(target))
|
||||
})
|
||||
.collect();
|
||||
// One stat per entry dominates a large folder (and every stat is a round trip on a network
|
||||
// share): stat in parallel; small folders stay on this thread.
|
||||
let mut entries: Vec<(bool, FileEntry)> = paths
|
||||
.into_par_iter()
|
||||
.with_min_len(256)
|
||||
.filter_map(|path| {
|
||||
let name = path.file_name()?.to_string_lossy().into_owned();
|
||||
let lmeta = fs::symlink_metadata(&path).ok()?;
|
||||
let (kind, meta, target_kind) = if lmeta.file_type().is_symlink() {
|
||||
match fs::metadata(&path) {
|
||||
Ok(m) => {
|
||||
let target = if m.is_dir() { EntryKind::Dir } else { EntryKind::File };
|
||||
(EntryKind::Symlink, m, Some(target))
|
||||
}
|
||||
Err(_) => (EntryKind::Symlink, lmeta, None),
|
||||
}
|
||||
Err(_) => (EntryKind::Symlink, lmeta, None),
|
||||
}
|
||||
} else if lmeta.is_dir() {
|
||||
(EntryKind::Dir, lmeta, None)
|
||||
} else {
|
||||
(EntryKind::File, lmeta, None)
|
||||
};
|
||||
let is_dir = meta.is_dir();
|
||||
let rel = path.strip_prefix(&base).unwrap_or(&path);
|
||||
let excluded = excludes.is_excluded(rel);
|
||||
let ignored = excluded || gitignore.is_ignored(&path, is_dir);
|
||||
entries.push((
|
||||
is_dir,
|
||||
FileEntry {
|
||||
hidden: name.starts_with('.'),
|
||||
size: if is_dir { 0 } else { meta.len() },
|
||||
mtime_ms: mtime_ms(&meta),
|
||||
name,
|
||||
path: path.into(),
|
||||
kind,
|
||||
ignored,
|
||||
excluded,
|
||||
target_kind,
|
||||
},
|
||||
));
|
||||
}
|
||||
entries.sort_by(|(da, a), (db, b)| db.cmp(da).then_with(|| natural_cmp(&a.name, &b.name)));
|
||||
} else if lmeta.is_dir() {
|
||||
(EntryKind::Dir, lmeta, None)
|
||||
} else {
|
||||
(EntryKind::File, lmeta, None)
|
||||
};
|
||||
let is_dir = meta.is_dir();
|
||||
let rel = path.strip_prefix(&base).unwrap_or(&path);
|
||||
let excluded = excludes.is_excluded(rel);
|
||||
let ignored = excluded || gitignore.is_ignored(&path, is_dir);
|
||||
Some((
|
||||
is_dir,
|
||||
FileEntry {
|
||||
hidden: name.starts_with('.'),
|
||||
size: if is_dir { 0 } else { meta.len() },
|
||||
mtime_ms: mtime_ms(&meta),
|
||||
name,
|
||||
path: path.into(),
|
||||
kind,
|
||||
ignored,
|
||||
excluded,
|
||||
target_kind,
|
||||
},
|
||||
))
|
||||
})
|
||||
.collect();
|
||||
entries.par_sort_by(|(da, a), (db, b)| db.cmp(da).then_with(|| natural_cmp(&a.name, &b.name)));
|
||||
Ok(entries.into_iter().map(|(_, e)| e).collect())
|
||||
}
|
||||
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -850,6 +850,7 @@ mod tests {
|
||||
"agent": "",
|
||||
"agentModel": "",
|
||||
"agentEffort": "",
|
||||
"agentButton": true,
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
@@ -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")]);
|
||||
}
|
||||
|
||||
@@ -55,7 +55,9 @@ Codex keeps its own project trust decision. If it disables the current project's
|
||||
<Step title="Pick the agent and its settings">
|
||||
Choose the agent, and its model, mode and other options when it offers them. Cached models appear immediately; the selected agent's catalog refreshes in the background when it is more than 15 minutes old, without sending a prompt or attaching project MCP servers.
|
||||
|
||||
Model-specific effort levels and context options are looked up when you select a model whose settings are not cached, even before its first task. **Loading model settings…** appears beside the model during this short-lived lookup; no prompt is sent and existing tasks are not changed. Each model keeps its own choices, and models that report no effort control do not borrow another model's levels.
|
||||
Click the model name to switch models, or click the settings beside it (for example **High · 1M**) to change effort or context size directly. In the model list, use the arrow on a model's row to see its settings without selecting it. Changing a setting selects that model; going back without an edit keeps the previous selection. These controls are also available in an existing chat.
|
||||
|
||||
If settings aren't cached, OpenIDEA looks them up when you select or inspect the model. No prompt is sent. Each model keeps its own draft choices, and models that report no effort control do not borrow another model's levels.
|
||||
|
||||
After changing the agent CLI or account, open the model picker and choose **Refresh models**. Refreshes share one lookup and have a 30-second cooldown after completion, including failures. Selecting an uncached model's settings does not wait for another model's cooldown. Cached choices remain usable while refreshing or after a failure; use **Refresh models** to retry a failed lookup after its cooldown.
|
||||
|
||||
@@ -123,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**.
|
||||
@@ -137,7 +139,7 @@ Tasks are saved per project and survive restarts. When the agent supports resumi
|
||||
- **Agent Configs**: discovers servers already configured in `~/.copilot/mcp-config.json` (and installed Copilot CLI plugins), `~/.claude.json`, `~/.codex/config.toml`, `~/.cursor/mcp.json`, `~/.gemini/settings.json`, `~/.jetbrains/mcp/mcp.json`, `.mcp.json`, and `.vscode/mcp.json` so you can import them into Global or Project settings with one click. You can also add or edit servers via structured fields or raw `mcpServers` JSON (**Add from JSON**), and run **Test Connection** to inspect the tools a server advertises.
|
||||
- **Per-session (`MCP` / `/mcp`)**: in both **New Agent Task** and active task conversations, open **MCP** in the composer toolbar (or run `/mcp`) to enable or disable individual servers—including the built-in `openidea` server—for that task only, or click **Reset** to return to the inherited defaults.
|
||||
|
||||
While the agent works, the line under the conversation says what it is doing: thinking, reading, editing, running a command, writing its reply. **Settings › Agents › Working Status** can show playful words for what it does there instead; they are off by default. Once turned on, they take turns from the moment the work changes, or only after the agent reports nothing new for a number of seconds (0 to 600, 0 by default); screen readers still hear what the agent is doing. Each word stays eight seconds while the agent keeps at the same work, and at least three when it moves on, so the line doesn't flicker. The same page replaces the words: pick what the status says (**Reading…**, **Running a command…**…) and add or remove its words. **Restore Built-in Words** brings back OpenIDEA's; an activity left without words keeps its plain status.
|
||||
While the agent works, the line under the conversation says what it is doing: thinking, reading, editing, running a command, writing its reply.
|
||||
|
||||
## Add a custom agent
|
||||
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -123,7 +123,7 @@ These commands are in the **Run** menu and on the Debug tool window toolbar.
|
||||
While the program is suspended:
|
||||
|
||||
- The **Variables** view shows the variables of the selected frame. Right-click a value for **Set Value…** (`F2`), **Copy Value**, **Copy Name**, **Jump to Source** (`F4`) and **Add to Watches**.
|
||||
- **Watches** appear at the top of the Variables view and are re-evaluated on every stop and frame change. Add one with **Add to Watches**; remove it with **Remove Watch**.
|
||||
- **Watches** appear at the top of the Variables view and are re-evaluated on every stop and frame change. Add one with **Add to Watches**; remove it with **Remove Watch**, or all of them with **Remove All Watches**.
|
||||
- Hovering a variable in the editor shows its value. `⌥`-click (`Alt`-click) or **Quick Evaluate Expression** (`⌘⌥F8` / `Ctrl+Alt+F8`) evaluates the expression under the mouse or the selection.
|
||||
- Values of local variables are shown inline after the lines that use them.
|
||||
- **Evaluate Expression…** (`⌥F8` / `Alt+F8`) opens a dialog that evaluates any expression in the selected frame, keeps a history, and can add the expression to watches.
|
||||
|
||||
@@ -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`).
|
||||
|
||||
@@ -160,7 +160,7 @@ A **Compound** configuration starts several configurations at once. Run it to st
|
||||
Each launch opens a tab in the **Run** tool window (bottom). The toolbar has **Rerun**, **Debug**, **Rerun Failed Tests** (for test runs), **Update Application**, **Find…**, **Scroll to End**, **Soft-Wrap**, **Clear All** and **Edit Configurations…**.
|
||||
|
||||
- File paths and stack trace frames in the output are links.
|
||||
- Repeated lines can be folded; configure the patterns in **Settings › Build, Execution, Deployment › Console**, along with the buffer size and the console encoding.
|
||||
- Repeated lines can be folded; configure the patterns in **Settings › Build, Execution, Deployment › Console**, along with the buffer size and the console encoding. **Fold Lines Like This** in the console's context menu opens that page with the selected text (or the clicked line) added as a pattern.
|
||||
- Log lines can take the colour of their level (`ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`); colours the program prints itself are kept. Turn it on and pick the colours in **Settings › Build, Execution, Deployment › Console**.
|
||||
- For test runs the tab shows a test tree next to the output. See [Testing](/en/guide/testing).
|
||||
|
||||
|
||||
@@ -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.
|
||||
@@ -206,6 +207,7 @@ Limits: interactive rebase doesn't support ranges with merge commits, and **Undo
|
||||
|
||||
- **Shelve Changes…** lets you pick files and a name; the changes are then reverted.
|
||||
- **Unshelve…** applies a shelf (or one file of it) with a three-way merge, into a changelist you choose.
|
||||
- **Shelve Silently** (`⇧⌘H` / `Ctrl+Shift+H`, also on the Changes toolbar) shelves the selected changes, or the active changelist, without the dialog: one shelf per changelist, named after it. **Unshelve Silently** (`⌥⌘U` / `Ctrl+Alt+U` in the Shelf) applies the selected shelf or file into the changelist with the shelf's name, else the active one.
|
||||
- The **Shelf** tab shows shelves with diff, compare with local, patch export, rename and delete.
|
||||
|
||||
Turn on **Combine stashes and shelves in one tab** in the Git settings to show both in one tab.
|
||||
@@ -237,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
|
||||
|
||||
|
||||
@@ -55,7 +55,9 @@ Codex 有自己的项目信任设置。如果它禁用了当前项目的 `.codex
|
||||
<Step title="选择 agent 及其设置">
|
||||
选择 agent,以及它提供的模型、模式等选项。缓存的模型会立即显示;所选 agent 的模型列表超过 15 分钟未更新时,会在后台刷新,不发送提示词,也不接入项目 MCP 服务器。
|
||||
|
||||
选择尚未缓存设置的模型时,会按需查询该模型的思考强度和上下文选项,无需先运行任务。短暂查询期间,模型旁会显示**正在加载模型设置…**;查询不发送提示词,也不更改现有任务。每个模型分别保留你选择的设置;明确不提供思考强度的模型不会沿用其他模型的强度选项。
|
||||
点击模型名称可切换模型;点击旁边的设置(如 **High · 1M**)可直接调整思考强度或上下文大小。在模型列表中,点击一行右侧的箭头可以先查看该模型的设置。修改设置时才会选中该模型,直接返回则保留原来的选择。在已有对话中也可以这样操作。
|
||||
|
||||
选择模型或查看其设置时,如果还没有缓存,OpenIDEA 会按需查询,无需发送提示词。草稿分别保留各模型的选择;未提供思考强度的模型不会沿用其他模型的选项。
|
||||
|
||||
更改 agent CLI 或账号后,打开模型选择器并单击 **刷新模型**。并发刷新会共用一次查询;每次查询完成后(包括失败)都有 30 秒冷却时间。查询其他未缓存模型的设置无需等待前一个模型的冷却时间。刷新中或刷新失败后,缓存选项仍可使用;查询失败后,可在冷却结束后用**刷新模型**重试。
|
||||
|
||||
@@ -123,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)和 **会话花费**。
|
||||
@@ -137,7 +139,7 @@ agent 运行过一个任务后,新任务会以它自动批准所有操作的
|
||||
- **智能体配置**:自动发现 `~/.copilot/mcp-config.json`(及已安装的 Copilot CLI 插件)、`~/.claude.json`、`~/.codex/config.toml`、`~/.cursor/mcp.json`、`~/.gemini/settings.json`、`~/.jetbrains/mcp/mcp.json`、`.mcp.json` 和 `.vscode/mcp.json` 中已配置的服务器,可一键导入到全局或项目设置。添加或编辑服务器时既可使用表单,也可直接粘贴 `mcpServers` JSON(**从 JSON 添加**),并可通过 **测试连接** 查看服务器声明的工具列表。
|
||||
- **按会话覆盖(`MCP` / `/mcp`)**:在 **新建 Agent 任务** 和进行中的任务对话中,单击输入框工具栏的 **MCP**(或输入 `/mcp`),即可仅针对当前任务开启或关闭任意服务器(包括内置的 `openidea` 服务器),或点击 **重置** 恢复继承的默认状态。
|
||||
|
||||
agent 工作时,对话下方的状态行显示它正在做什么:思考、读取、编辑、运行命令、输出回复。在 **设置 › 智能体 › 工作状态** 中可以让这里改为显示与当前工作相关的趣味文字,默认关闭。开启后,工作一变化就轮换显示,也可以设置在 agent 无新进展多少秒后才显示(0 到 600,默认 0);屏幕阅读器读出的仍是 agent 实际在做的事。agent 持续做同一类工作时,每条文字停留八秒;转向其他工作时也至少停留三秒,状态行不会频繁跳动。同一页面还可以替换这些文字:选择状态(**正在读取…**、**正在运行命令…**…),再添加或移除对应的文字。**恢复内置文字** 会换回 OpenIDEA 自带的文字;没有任何文字的状态只显示实际进展。
|
||||
agent 工作时,对话下方的状态行显示它正在做什么:思考、读取、编辑、运行命令、输出回复。
|
||||
|
||||
## 添加自定义 agent
|
||||
|
||||
|
||||
@@ -57,6 +57,7 @@ description: "代码补全、导航、查找用法、文档、层次结构与文
|
||||
| **下一个方法** / **上一个方法** | `⌃⇧↓` / `⌃⇧↑` | `Alt+Down` / `Alt+Up` |
|
||||
|
||||
- 在声明本身上执行 **转到声明或用法**,会改为显示它的用法。
|
||||
- 没有任何实现时,**转到实现** 会跳转到符号自身的声明,与 IntelliJ IDEA 一致。
|
||||
- 按住 `⌘` / `Ctrl` 把鼠标悬停在名称上,名称会显示为链接,并附带简要信息。
|
||||
- 装订区域的图标标出被实现或被重写的类型和方法(↓),以及实现或重写了其他方法的方法(↑),单击即可跳转。
|
||||
- **导航 › 测试** 按命名约定在类和它的测试之间跳转;还没有测试时会提供 **创建新测试…**。
|
||||
|
||||
@@ -125,7 +125,7 @@ C 和 C++ 的配置也可以改用 GDB 14 及以上版本(`gdb -i dap`):
|
||||
程序挂起时:
|
||||
|
||||
- **变量** 视图显示选中帧的变量。右键点击某个值,可以 **设置值…**(`F2`)、**复制值**、**复制名称**、**跳转到源代码**(`F4`)和 **添加到监视**。
|
||||
- 监视表达式显示在变量视图顶部,每次停下或切换帧时重新计算。用 **添加到监视** 添加,用 **移除监视** 删除。
|
||||
- 监视表达式显示在变量视图顶部,每次停下或切换帧时重新计算。用 **添加到监视** 添加,用 **移除监视** 删除,用 **移除所有监视** 一次全部删除。
|
||||
- 在编辑器里悬停变量会显示它的值。`⌥` 点击(`Alt` 点击)或 **快速计算表达式**(`⌘⌥F8` / `Ctrl+Alt+F8`)计算鼠标下的表达式或选中的内容。
|
||||
- 局部变量的值会内联显示在使用它们的行尾。
|
||||
- **计算表达式…**(`⌥F8` / `Alt+F8`)打开对话框,在选中帧里计算任意表达式,带历史记录,也能把表达式加入监视。
|
||||
|
||||
@@ -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`)。
|
||||
|
||||
@@ -156,7 +156,7 @@ Maven 模块在 **自动** 和 **构建(Make)** 时由 jdtls(ECJ)构建
|
||||
每次启动都会在底部的 **运行** 工具窗口里开一个标签页。工具栏有 **重新运行**、**调试**、**重新运行失败的测试**(测试运行时)、**更新应用**、**查找…**、**滚动到末尾**、**软换行**、**全部清除** 和 **编辑配置…**。
|
||||
|
||||
- 输出里的文件路径和堆栈帧都可以点击跳转。
|
||||
- 重复的行可以折叠。折叠规则、缓冲区大小和控制台编码在 **设置 › 构建、执行、部署 › 控制台** 中配置。
|
||||
- 重复的行可以折叠。折叠规则、缓冲区大小和控制台编码在 **设置 › 构建、执行、部署 › 控制台** 中配置。控制台右键菜单中的 **折叠与此类似的行** 会打开该页面,并把选中的文本(或右键所在的行)添加为折叠规则。
|
||||
- 日志行可按级别着色(`ERROR`、`WARN`、`INFO`、`DEBUG`、`TRACE`);程序自行输出的颜色保持不变。默认关闭,可在 **设置 › 构建、执行、部署 › 控制台** 开启并修改颜色。
|
||||
- 测试运行时,标签页会在输出旁显示测试树,参见[测试](/zh/guide/testing)。
|
||||
|
||||
|
||||
@@ -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`)、**创建补丁…**、**拣选**、**签出修订**、**浏览此修订版本的仓库**、**与本地比较**、**将当前分支重置到此处…**、**还原提交**、**撤消提交…**、**新建分支…**、**新建标签…**、**在浏览器中查看** 等。选中两个提交时,**比较版本** 会比较它们。
|
||||
@@ -204,6 +205,7 @@ Git 工具窗口的 **日志** 标签页显示提交图。
|
||||
|
||||
- **搁置更改…**:选择文件并命名,之后这些更改会被还原。
|
||||
- **取消搁置…**:以三方合并的方式把搁置(或其中某个文件)应用到你选择的更改列表。
|
||||
- **静默搁置**(`⇧⌘H` / `Ctrl+Shift+H`,也在更改工具栏上)不弹对话框,直接搁置选中的更改(未选中时为活动更改列表):每个更改列表一个搁置,以列表名命名。**静默取消搁置**(在搁置中按 `⌥⌘U` / `Ctrl+Alt+U`)把选中的搁置或文件应用到与搁置同名的更改列表,没有则应用到活动更改列表。
|
||||
- **搁置** 标签页列出所有搁置,支持查看差异、与本地比较、导出补丁、重命名和删除。
|
||||
|
||||
在 Git 设置中打开 **在同一个标签页中合并显示贮藏和搁置**,两者会显示在同一个标签页里。
|
||||
@@ -235,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)。 |
|
||||
|
||||
## 暂不支持
|
||||
|
||||
|
||||
@@ -109,6 +109,7 @@ async function seed(
|
||||
model = "atlas",
|
||||
status: AgentTask["status"] = "ready",
|
||||
catalogOnly = false,
|
||||
offered = provider,
|
||||
) {
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
@@ -218,7 +219,7 @@ async function seed(
|
||||
if (surface === "new") store.openHome();
|
||||
else store.openTask(firstTask.id);
|
||||
},
|
||||
{ placement, surface, provider, firstTask, secondTask, subagent, model, status, modelId, catalogOnly },
|
||||
{ placement, surface, provider: offered, firstTask, secondTask, subagent, model, status, modelId, catalogOnly },
|
||||
);
|
||||
await expect(box(page)).toBeVisible();
|
||||
await page.evaluate(() => document.fonts.ready);
|
||||
@@ -233,9 +234,8 @@ function history(page: Page) {
|
||||
function modelButton(page: Page) {
|
||||
return page.getByRole("button", { name: "Model", exact: true }).filter({ visible: true });
|
||||
}
|
||||
/** The effort is shown on the model button, after the model's name. */
|
||||
function effortLabel(page: Page) {
|
||||
return modelButton(page).locator("[class*='modelDetail']");
|
||||
return page.getByRole("button", { name: /^Model settings:/ }).filter({ visible: true });
|
||||
}
|
||||
async function expectEffort(page: Page, name: string) {
|
||||
await expect(effortLabel(page)).toHaveText(name);
|
||||
@@ -284,6 +284,50 @@ async function expectNoSubmission(page: Page) {
|
||||
expect(await ipcCalls(page, "agent_create")).toEqual([]);
|
||||
}
|
||||
|
||||
for (const surface of ["new", "task"] as const) {
|
||||
test(`${surface}: configure another model from its row, then edit its context from the composer`, async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const context = option(
|
||||
"context_tier",
|
||||
"model_config",
|
||||
[
|
||||
["default", "200K"],
|
||||
["long_context", "1M"],
|
||||
],
|
||||
"default",
|
||||
);
|
||||
const offered = {
|
||||
...provider,
|
||||
thoughtLevels: { ...provider.thoughtLevels, atlas: [atlas, context], swift: [swift, context] },
|
||||
};
|
||||
await seed(page, "editor", surface, "atlas", "ready", false, offered);
|
||||
await box(page).fill("Review the project structure");
|
||||
await modelButton(page).click();
|
||||
const row = page.getByRole("option", { name: /^Swift\b/ });
|
||||
await row.hover();
|
||||
const configure = row.getByRole("button", { name: "Configure Swift…" });
|
||||
if (surface === "task") await configure.press("Enter");
|
||||
else await configure.click();
|
||||
await expect(modelButton(page)).toHaveText("Atlas");
|
||||
await expect(page.getByRole("radio", { name: "Gentle" })).toHaveCount(0);
|
||||
await page.getByRole("radio", { name: "Thorough" }).click();
|
||||
await expect(modelButton(page)).toHaveText("Swift");
|
||||
await expect(page.getByRole("radio", { name: "Thorough" })).toBeChecked();
|
||||
await page.keyboard.press("Escape");
|
||||
const settings = page.getByRole("button", { name: /^Model settings:/ });
|
||||
await expect(settings).toHaveText("Thorough · 200K");
|
||||
await settings.click();
|
||||
await page.getByRole("radio", { name: "1M" }).click();
|
||||
await expect(settings).toHaveText("Thorough · 1M");
|
||||
await page.getByRole("button", { name: "Back to models" }).click();
|
||||
await expect(page.getByRole("listbox", { name: "Model", exact: true })).toBeVisible();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(box(page)).toHaveText("Review the project structure");
|
||||
await expectNoSubmission(page);
|
||||
});
|
||||
}
|
||||
|
||||
for (const placement of ["editor", "toolWindow"] as const) {
|
||||
test(`${placement}: existing task cycles advertised values and wraps without editing, moving focus or scrolling`, async ({
|
||||
workbench: page,
|
||||
@@ -379,7 +423,7 @@ test("Settings and effort popup exclude the agent shortcut", async ({ workbench:
|
||||
await expect(search).toBeFocused();
|
||||
await expect(search).toHaveValue("keymap");
|
||||
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await modelButton(page).click();
|
||||
await effortLabel(page).click();
|
||||
const popup = page.getByRole("radiogroup", { name: "Effort Level", exact: true });
|
||||
await expect(popup).toBeVisible();
|
||||
await page.keyboard.press("Alt+t");
|
||||
@@ -603,7 +647,7 @@ test("New Task discovers uncached model effort before the first prompt", async (
|
||||
await page.screenshot({ path: testInfo.outputPath("model-settings-loading.png") });
|
||||
await page.evaluate(() => document.dispatchEvent(new Event("test:model-settings-ready")));
|
||||
await expectEffort(page, "Quick");
|
||||
await modelButton(page).click();
|
||||
await effortLabel(page).click();
|
||||
const efforts = page.getByRole("radiogroup", { name: "Effort Level", exact: true });
|
||||
await expect(efforts.getByRole("radio", { name: "Quick", exact: true })).toBeVisible();
|
||||
await expect(efforts.getByRole("radio", { name: "Thorough", exact: true })).toBeVisible();
|
||||
@@ -636,7 +680,7 @@ test("an existing chat can choose effort for a refreshed model before sending",
|
||||
await expect(loading).toHaveCount(0);
|
||||
await expect(modelButton(page)).toHaveAttribute("title", /^Model: Swift\b/);
|
||||
await expectEffort(page, "Quick");
|
||||
await modelButton(page).click();
|
||||
await effortLabel(page).click();
|
||||
const efforts = page.getByRole("radiogroup", { name: "Effort Level", exact: true });
|
||||
await expect(efforts.getByRole("radio", { name: "Gentle", exact: true })).toHaveCount(0);
|
||||
await efforts.getByRole("radio", { name: "Thorough", exact: true }).click();
|
||||
|
||||
@@ -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,61 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("line bookmarks keep their code or description readable in the dock", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 880, height: 640 });
|
||||
const name = "QuarterlySettlementReconciliationCoordinator.ts";
|
||||
const path = `/dev/acme-api/${name}`;
|
||||
const code = "reconcileCheckoutOrders();";
|
||||
const description = "Review settlement totals";
|
||||
await page.evaluate(
|
||||
async ({ path, code }) => {
|
||||
const backendModule = "/src/editor/core/backend.ts";
|
||||
const { docBackend } = await import(/* @vite-ignore */ backendModule);
|
||||
docBackend().files.set(path, [...Array(27).fill("// Settlement rules"), code, "verifyTotals();", ""].join("\n"));
|
||||
const services = "/src/workbench/contributions.ts";
|
||||
const { editorService } = await import(/* @vite-ignore */ services);
|
||||
await editorService().openFile(path);
|
||||
},
|
||||
{ path, code },
|
||||
);
|
||||
await expect(page.locator(".cm-content")).toContainText(code);
|
||||
await page.evaluate(
|
||||
async ({ path, description }) => {
|
||||
const actionsModule = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ actionsModule);
|
||||
await executeAction("navigate.toggleBookmark", { path, line: 27 });
|
||||
await executeAction("navigate.toggleBookmark", { path, line: 29 });
|
||||
const bookmarkModule = "/src/features/search/bookmarks/store.ts";
|
||||
const { assignMnemonic, updateBookmarks } = await import(/* @vite-ignore */ bookmarkModule);
|
||||
updateBookmarks((items: unknown[]) => assignMnemonic(items, path, 28, "verifyTotals();", "4", description));
|
||||
await executeAction("toolwindow.bookmarks");
|
||||
const layoutModule = "/src/workbench/toolwindows/store.ts";
|
||||
const { setToolWindowSize } = await import(/* @vite-ignore */ layoutModule);
|
||||
setToolWindowSize("left", 240);
|
||||
},
|
||||
{ path, description },
|
||||
);
|
||||
|
||||
const tree = page.getByRole("tree", { name: "Bookmarks" });
|
||||
await expect(tree.getByText(name, { exact: true })).toBeVisible();
|
||||
const snippet = tree.getByText(code, { exact: true });
|
||||
await expect.poll(() => snippet.evaluate((el) => el.clientWidth)).toBeGreaterThanOrEqual(105);
|
||||
await expect(tree.getByText("28:", { exact: true })).toBeVisible();
|
||||
await expect(tree.getByText("29:", { exact: true })).toBeVisible();
|
||||
await expect(tree.getByText(description, { exact: true })).toBeVisible();
|
||||
await expect(tree.getByText("(empty line)", { exact: true })).toBeVisible();
|
||||
expect(await tree.evaluate((el) => el.scrollWidth - el.clientWidth)).toBe(0);
|
||||
|
||||
const row = tree.getByRole("treeitem").filter({ hasText: code });
|
||||
await row.click();
|
||||
await page.keyboard.press("Enter");
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(async () => {
|
||||
const module = "/src/workbench/contributions.ts";
|
||||
const { editorService } = await import(/* @vite-ignore */ module);
|
||||
const cursor = editorService().activeCursor();
|
||||
return { path: cursor?.path, line: cursor?.line };
|
||||
}),
|
||||
)
|
||||
.toEqual({ path, line: 27 });
|
||||
});
|
||||
@@ -0,0 +1,71 @@
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Branch comparison keeps both commit ranges and the diff action visible", async ({ workbench: page }) => {
|
||||
const branch = "feature/settlement-reconciliation-and-international-ledger-reporting";
|
||||
const current = "feature/review-quarterly-settlement-audit";
|
||||
const incomingSubject = "Keep regional settlement references stable during the report export";
|
||||
const outgoingSubject = "Preserve the audit trail for settlement retries";
|
||||
await page.setViewportSize({ width: 1120, height: 760 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ branch, current, incomingSubject, outgoingSubject }) => {
|
||||
const root = "/dev/acme-api";
|
||||
const branchInfo = {
|
||||
head: current,
|
||||
headCommit: "b".repeat(40),
|
||||
upstream: null,
|
||||
ahead: 0,
|
||||
behind: 0,
|
||||
operation: null,
|
||||
};
|
||||
const entry = (letter: string, summary: string) => ({
|
||||
id: letter.repeat(40),
|
||||
shortId: letter.repeat(8),
|
||||
parents: ["a".repeat(40)],
|
||||
refs: [],
|
||||
summary,
|
||||
message: summary + "\n\nUpdate the audit report context.",
|
||||
author: "Sam Rivera",
|
||||
email: "[email protected]",
|
||||
timeMs: 1795100000000,
|
||||
});
|
||||
const h = window.__ipc.handlers;
|
||||
h.vcs_roots = () => [{ root, ...branchInfo }];
|
||||
h.vcs_branch_info = () => branchInfo;
|
||||
h.vcs_status = () => [];
|
||||
h.vcs_log = ({ query }) =>
|
||||
(query as { range: string }).range === `HEAD..${branch}`
|
||||
? [entry("c", incomingSubject)]
|
||||
: [entry("b", outgoingSubject)];
|
||||
h.window_open_comparison = () => null;
|
||||
const store = "/src/features/vcs/store.ts";
|
||||
const { useVcs } = await import(/* @vite-ignore */ store);
|
||||
useVcs.setState({ available: true, root, repo: root, roots: [root], branch: branchInfo });
|
||||
const path = "/src/features/vcs/CompareBranches.tsx";
|
||||
(await import(/* @vite-ignore */ path)).showCompareBranches(branch);
|
||||
},
|
||||
{ branch, current, incomingSubject, outgoingSubject },
|
||||
);
|
||||
const dialog = page.getByRole("dialog", { name: new RegExp(`Compare ${current}`) });
|
||||
await expect(dialog.getByRole("listbox")).toHaveCount(2);
|
||||
const incoming = dialog.getByRole("listbox", { name: `In ${branch}, not in ${current}` });
|
||||
const outgoing = dialog.getByRole("listbox", { name: `In ${current}, not in ${branch}` });
|
||||
await expect(incoming.getByText(incomingSubject, { exact: true })).toBeVisible();
|
||||
await expect(outgoing.getByText(outgoingSubject, { exact: true })).toBeVisible();
|
||||
const divider = dialog.getByRole("separator", { name: "Resize branch comparison panes" });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
const start = (await divider.boundingBox())!.y;
|
||||
await divider.focus();
|
||||
await page.keyboard.press("ArrowDown");
|
||||
await expect.poll(async () => (await divider.boundingBox())!.y).toBeGreaterThan(start + 1);
|
||||
|
||||
await page.setViewportSize({ width: 440, height: 660 });
|
||||
const heading = dialog.getByRole("heading", { name: new RegExp(`In ${branch}`) });
|
||||
await expect.poll(() => heading.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await expect(incoming.getByRole("option")).toBeVisible();
|
||||
await expect(outgoing.getByRole("option")).toBeVisible();
|
||||
await dialog.getByRole("button", { name: "Show Diff", exact: true }).click();
|
||||
await expect
|
||||
.poll(() => ipcCalls(page, "window_open_comparison"))
|
||||
.toMatchObject([{ comparison: { from: { rev: branch }, to: { rev: "HEAD" }, repo: "/dev/acme-api" } }]);
|
||||
});
|
||||
@@ -0,0 +1,50 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("keeps breakpoint details editable when the dialog gets narrow", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 500, height: 480 });
|
||||
await page.evaluate(async () => {
|
||||
const actionsModule = "/src/platform/actions.ts";
|
||||
const storeModule = "/src/features/debugger/breakpoints/store.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ actionsModule);
|
||||
const { addBreakpoint } = await import(/* @vite-ignore */ storeModule);
|
||||
addBreakpoint("/dev/acme-api/CheckInternationalSettlementBeforeDispatch.java", 7, {
|
||||
condition: "amount > 100",
|
||||
});
|
||||
addBreakpoint("/dev/acme-api/Receipt.java", 4);
|
||||
await executeAction("debug.viewBreakpoints");
|
||||
});
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Breakpoints" });
|
||||
const list = dialog.getByRole("listbox", { name: "All breakpoints" });
|
||||
const condition = dialog.locator('input[aria-label="Condition"]');
|
||||
await expect(condition).toHaveValue("amount > 100");
|
||||
await expect.poll(async () => (await condition.boundingBox())?.width ?? 0).toBeGreaterThanOrEqual(240);
|
||||
await expect(dialog.getByRole("button", { name: "Done", exact: true })).toBeInViewport({ ratio: 1 });
|
||||
await condition.fill("amount > 250");
|
||||
await dialog.getByRole("checkbox", { name: "Evaluate and log", exact: true }).check();
|
||||
await dialog.getByRole("textbox", { name: "Evaluate and log", exact: true }).fill("total: {amount}");
|
||||
const first = list.getByRole("option", { name: /CheckInternationalSettlementBeforeDispatch\.java:8/ });
|
||||
await expect(first.getByText(":8", { exact: true })).toBeInViewport({ ratio: 1 });
|
||||
await list.getByRole("option", { name: /Receipt\.java:5/ }).click();
|
||||
await expect(condition).toHaveValue("");
|
||||
await first.click();
|
||||
await expect(condition).toHaveValue("amount > 250");
|
||||
await expect(dialog.getByRole("textbox", { name: "Evaluate and log", exact: true })).toHaveValue("total: {amount}");
|
||||
|
||||
await page.setViewportSize({ width: 1080, height: 760 });
|
||||
const divider = dialog.locator('[data-separator][aria-orientation="vertical"]');
|
||||
await expect(divider).toBeInViewport();
|
||||
const oldWidth = (await list.boundingBox())!.width;
|
||||
const handle = (await divider.boundingBox())!;
|
||||
await page.mouse.move(handle.x + handle.width / 2, handle.y + handle.height / 2);
|
||||
await page.mouse.down();
|
||||
await page.mouse.move(handle.x + 60, handle.y + handle.height / 2, { steps: 4 });
|
||||
await page.mouse.up();
|
||||
await expect.poll(async () => (await list.boundingBox())?.width ?? 0).toBeGreaterThan(oldWidth + 20);
|
||||
await expect(condition).toHaveValue("amount > 250");
|
||||
const request = dialog.getByRole("textbox", { name: "Part of a request URL" });
|
||||
await request.scrollIntoViewIfNeeded();
|
||||
await expect(request).toBeInViewport({ ratio: 1 });
|
||||
await dialog.getByRole("button", { name: "Done", exact: true }).click();
|
||||
await expect(dialog).toBeHidden();
|
||||
});
|
||||
@@ -0,0 +1,75 @@
|
||||
import type { MethodSignature } from "../src/bindings";
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
const signature: MethodSignature = {
|
||||
methodIdentifier: "invoice",
|
||||
modifier: "",
|
||||
returnType: "Invoice",
|
||||
methodName: "prepareInvoiceForInternationalSettlement",
|
||||
parameters: [
|
||||
["Order", "order"],
|
||||
["String", "billingCurrency"],
|
||||
["BigDecimal", "amountBeforeDiscount"],
|
||||
["Map<String, BigDecimal>", "taxRatesByJurisdiction"],
|
||||
["List<Adjustment>", "settlementAdjustments"],
|
||||
["RoundingMode", "roundingMode"],
|
||||
["LocalDate", "scheduledSettlementDate"],
|
||||
["boolean", "includeTaxBreakdown"],
|
||||
].map(([type, name], originalIndex) => ({ type: type!, name: name!, originalIndex, defaultValue: "" })),
|
||||
exceptions: [],
|
||||
};
|
||||
|
||||
test("keeps parameter rows and a long signature preview usable in a short dialog", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 490, height: 520 });
|
||||
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");
|
||||
});
|
||||
const editor = page.locator(".cm-editor .cm-content");
|
||||
await expect(editor).toBeVisible();
|
||||
await stubDesktop(page);
|
||||
const fontSize = await editor.evaluate(async (content, signature) => {
|
||||
window.__ipc.handlers.lsp_signature_info = () => signature;
|
||||
const viewModule = "/node_modules/.vite/deps/@codemirror_view.js";
|
||||
const prefsModule = "/src/editor/core/cm/prefs.ts";
|
||||
const { EditorView } = await import(/* @vite-ignore */ viewModule);
|
||||
const { stepFontZoom } = await import(/* @vite-ignore */ prefsModule);
|
||||
const base = Number.parseFloat(getComputedStyle(content).fontSize);
|
||||
const view = EditorView.findFromDOM(content as HTMLElement)!;
|
||||
stepFontZoom(view, 4);
|
||||
view.focus();
|
||||
return `${base + 4}px`;
|
||||
}, signature);
|
||||
await expect(editor).toHaveCSS("font-size", fontSize);
|
||||
await page.keyboard.press("Meta+F6");
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Change Signature" });
|
||||
const table = dialog.getByRole("table", { name: "Parameters" });
|
||||
const names = table.getByRole("textbox", { name: "Name", exact: true });
|
||||
await expect(names.first()).toBeInViewport({ ratio: 1 });
|
||||
const defaults = table.getByRole("columnheader", { name: "Default value", exact: true });
|
||||
await expect(defaults).toHaveCount(0);
|
||||
const preview = dialog.locator("pre");
|
||||
await expect(preview).toBeInViewport({ ratio: 1 });
|
||||
await expect(preview).toHaveCSS("font-size", fontSize);
|
||||
await expect(names.first()).toHaveCSS("font-size", fontSize);
|
||||
expect(
|
||||
await preview.evaluate((el) => el.scrollHeight > el.clientHeight && el.scrollWidth <= el.clientWidth + 1),
|
||||
).toBe(true);
|
||||
await expect(dialog.getByRole("button", { name: "Cancel" })).toBeInViewport({ ratio: 1 });
|
||||
|
||||
await dialog.getByRole("button", { name: "Add", exact: true }).click();
|
||||
await expect(defaults).toBeInViewport({ ratio: 1 });
|
||||
const addedType = table.getByRole("textbox", { name: "Type", exact: true }).last();
|
||||
await expect(addedType).toBeInViewport({ ratio: 1 });
|
||||
await addedType.fill("boolean");
|
||||
await names.last().fill("attachReceipt");
|
||||
await table.getByRole("textbox", { name: "Default value", exact: true }).last().fill("false");
|
||||
await dialog.getByRole("button", { name: "Move Up", exact: true }).click();
|
||||
await expect(names.nth(7)).toHaveValue("attachReceipt");
|
||||
await expect(preview).toContainText("boolean attachReceipt");
|
||||
await expect(dialog.getByRole("button", { name: "Preview", exact: true })).toBeEnabled();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(dialog).toBeHidden();
|
||||
});
|
||||
@@ -0,0 +1,62 @@
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
const REPO = "https://example.test/team/billing-service.git";
|
||||
|
||||
test("Clone Repository keeps URL, directory, and depth usable when the dialog narrows", async ({ workbench: page }) => {
|
||||
await stubDesktop(page);
|
||||
await page.setViewportSize({ width: 440, height: 620 });
|
||||
await page.evaluate(async (repo) => {
|
||||
window.__ipc.handlers["plugin:dialog|open"] = () => "/dev/workspaces";
|
||||
window.__ipc.handlers.vcs_clone = () => new Promise(() => {});
|
||||
const contributionsPath = "/src/workbench/contributions.ts";
|
||||
const { registerCloneSource } = await import(/* @vite-ignore */ contributionsPath);
|
||||
registerCloneSource({ id: "team", label: "Team repositories", icon: "branch", component: () => null });
|
||||
const actionsPath = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ actionsPath);
|
||||
await executeAction("vcs.clone", repo);
|
||||
}, REPO);
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Clone Repository" });
|
||||
const sources = dialog.getByRole("complementary", { name: "Clone source" });
|
||||
const url = dialog.getByRole("textbox", { name: "URL:" });
|
||||
await expect(url).toHaveValue(REPO);
|
||||
await expect.poll(async () => (await url.boundingBox())!.width).toBeGreaterThan(180);
|
||||
|
||||
const form = dialog.locator("form");
|
||||
const position = () =>
|
||||
form.evaluate((el) => {
|
||||
const source = el.parentElement!.querySelector("aside")!.getBoundingClientRect();
|
||||
const body = el.getBoundingClientRect();
|
||||
return { below: body.top >= source.bottom, beside: body.left >= source.right };
|
||||
});
|
||||
await expect.poll(async () => (await position()).below).toBe(true);
|
||||
expect(await form.evaluate((el) => el.scrollWidth === el.clientWidth)).toBe(true);
|
||||
|
||||
await dialog.getByRole("button", { name: "Browse…" }).click();
|
||||
const directory = dialog.getByRole("textbox", { name: "Directory:" });
|
||||
await expect(directory).toHaveValue("/dev/workspaces/billing-service");
|
||||
|
||||
const shallow = dialog.getByRole("checkbox", { name: /^Shallow clone/ });
|
||||
const depth = dialog.getByRole("spinbutton", { name: "Clone depth" });
|
||||
await expect(depth).toBeDisabled();
|
||||
await shallow.check();
|
||||
await depth.fill("0");
|
||||
const clone = dialog.getByRole("button", { name: "Clone", exact: true });
|
||||
await expect(clone).toBeDisabled();
|
||||
await depth.fill("3");
|
||||
|
||||
await page.setViewportSize({ width: 1050, height: 750 });
|
||||
await expect.poll(async () => (await position()).beside).toBe(true);
|
||||
await sources.getByRole("button", { name: "Team repositories" }).click();
|
||||
await expect(url).toBeHidden();
|
||||
await sources.getByRole("button", { name: "Repository URL" }).click();
|
||||
await expect(url).toHaveValue(REPO);
|
||||
await expect(directory).toHaveValue("/dev/workspaces/billing-service");
|
||||
await expect(depth).toHaveValue("3");
|
||||
|
||||
await page.setViewportSize({ width: 440, height: 620 });
|
||||
await clone.click();
|
||||
await expect
|
||||
.poll(() => ipcCalls(page, "vcs_clone"))
|
||||
.toEqual([expect.objectContaining({ url: REPO, dest: "/dev/workspaces/billing-service", depth: 3 })]);
|
||||
});
|
||||
@@ -0,0 +1,53 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Code Style keeps settings reachable by tab, keyboard, and search in a narrow pane", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 620, height: 720 });
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await expect(dialog).toBeVisible();
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(async () => {
|
||||
window.__ipc.handlers.languages = () => [
|
||||
{ id: "typescript", name: "TypeScript", indent: { tabSize: 2, insertSpaces: true }, lineComment: "//" },
|
||||
];
|
||||
const languageList = "/src/platform/languageList.ts";
|
||||
(await import(/* @vite-ignore */ languageList)).languageListChanged();
|
||||
});
|
||||
|
||||
const search = dialog.getByRole("textbox", { name: "Search settings" });
|
||||
await search.fill("typescript");
|
||||
await dialog.getByRole("treeitem", { name: "TypeScript", exact: true, level: 3 }).click();
|
||||
await search.clear();
|
||||
|
||||
const tabs = dialog.getByRole("tablist", { name: "Code Style" });
|
||||
const indents = tabs.getByRole("tab", { name: "Tabs and Indents" });
|
||||
const wrapping = tabs.getByRole("tab", { name: "Wrapping", exact: true });
|
||||
const comments = tabs.getByRole("tab", { name: "Comment Code" });
|
||||
await expect(indents).toHaveAttribute("aria-selected", "true");
|
||||
const size = dialog.getByRole("textbox", { name: "Tab size", exact: true });
|
||||
const indent = dialog.getByRole("textbox", { name: "Indent", exact: true });
|
||||
await expect(indent).toBeVisible();
|
||||
expect((await indent.boundingBox())!.x).toBeCloseTo((await size.boundingBox())!.x, 0);
|
||||
await size.fill("6");
|
||||
await indents.press("ArrowRight");
|
||||
await expect(wrapping).toBeFocused();
|
||||
await expect(dialog.getByRole("textbox", { name: "Hard wrap at", exact: true })).toBeVisible();
|
||||
await expect(size).toBeHidden();
|
||||
|
||||
await search.fill("TypeScript line comment at first column");
|
||||
await expect(comments).toHaveAttribute("aria-selected", "true");
|
||||
await expect(dialog.getByRole("checkbox", { name: "Line comment at first column" })).toBeVisible();
|
||||
await indents.click();
|
||||
await expect(size).toHaveValue("6");
|
||||
await page.setViewportSize({ width: 520, height: 720 });
|
||||
const body = dialog.locator("[class*='pageBody']");
|
||||
await expect.poll(() => body.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await expect(dialog.getByRole("button", { name: "Copy to Project", exact: true })).toBeVisible();
|
||||
|
||||
await search.fill("do not format");
|
||||
await dialog.getByRole("treeitem", { name: "Code Style", exact: true, level: 2 }).click();
|
||||
await expect(dialog.getByRole("tab", { name: "Formatter", exact: true })).toHaveAttribute("aria-selected", "true");
|
||||
await expect(dialog.getByRole("listbox", { name: "Do not format" })).toBeVisible();
|
||||
});
|
||||
@@ -0,0 +1,40 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("Color Scheme keeps the preview visible while editing an attribute in narrow Settings", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 1120, height: 760 });
|
||||
await page.keyboard.press("Meta+,");
|
||||
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const search = settings.getByRole("textbox", { name: "Search settings" });
|
||||
await search.fill("Language Defaults");
|
||||
await settings.getByRole("treeitem", { name: "Language Defaults", exact: true }).click();
|
||||
await search.clear();
|
||||
|
||||
const divider = settings.getByRole("separator", { name: "Resize color scheme preview", exact: true });
|
||||
const tree = settings.getByRole("tree", { name: "Color scheme attributes", exact: true });
|
||||
const options = settings.getByRole("region", { name: "Color scheme options", exact: true });
|
||||
const preview = settings.getByLabel("Color scheme preview", { exact: true });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
expect((await tree.boundingBox())!.x).toBeLessThan((await options.boundingBox())!.x);
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 660 });
|
||||
await expect.poll(async () => (await tree.boundingBox())!.y).toBeLessThan((await options.boundingBox())!.y);
|
||||
const previewTop = (await preview.boundingBox())!.y;
|
||||
const token = preview.getByText("class", { exact: true }).first();
|
||||
await token.click();
|
||||
await expect(tree.getByRole("treeitem", { name: "Keyword", exact: true, selected: true })).toBeVisible();
|
||||
await options.getByRole("textbox", { name: "Foreground hex", exact: true }).fill("#118899");
|
||||
await expect(token).toHaveCSS("color", "rgb(17, 136, 153)");
|
||||
await expect(preview).toBeInViewport();
|
||||
expect((await preview.boundingBox())!.y).toBeCloseTo(previewTop, 0);
|
||||
await expect
|
||||
.poll(() => settings.locator("[class*='pageBody']").evaluate((el) => el.scrollWidth - el.clientWidth))
|
||||
.toBeLessThanOrEqual(1);
|
||||
await options.getByRole("checkbox", { name: "Semantic highlighting" }).scrollIntoViewIfNeeded();
|
||||
expect((await preview.boundingBox())!.y).toBeCloseTo(previewTop, 0);
|
||||
|
||||
const before = (await divider.boundingBox())!.y;
|
||||
await divider.press("ArrowUp");
|
||||
await expect.poll(async () => (await divider.boundingBox())!.y).toBeLessThan(before - 1);
|
||||
});
|
||||
@@ -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,75 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
const functionName = "calculateRegionalSettlementFromExternalOrderBeforeReconciliation";
|
||||
const sourcePath = "/dev/acme-api/build.gradle.kts";
|
||||
|
||||
test("keeps frame sources and the keyboard selection visible in a narrow debug dock", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1120, height: 540 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ functionName, sourcePath }) => {
|
||||
const debugModule = "/src/features/debugger/state.ts";
|
||||
const layoutModule = "/src/workbench/toolwindows/store.ts";
|
||||
const servicesModule = "/src/workbench/contributions.ts";
|
||||
const { adoptSession } = await import(/* @vite-ignore */ debugModule);
|
||||
const { moveToolWindow, setToolWindowSize } = await import(/* @vite-ignore */ layoutModule);
|
||||
const { toolWindowService } = await import(/* @vite-ignore */ servicesModule);
|
||||
const workerFrame = {
|
||||
id: 51,
|
||||
name: "processOrder",
|
||||
path: sourcePath,
|
||||
line: 5,
|
||||
column: 0,
|
||||
presentationHint: null,
|
||||
};
|
||||
window.__ipc.handlers.debug_scopes = () => [];
|
||||
window.__ipc.handlers.debug_stack_trace = () => [workerFrame];
|
||||
adoptSession(91, {
|
||||
name: "Reconciliation",
|
||||
adapter: "debugpy",
|
||||
status: "paused",
|
||||
stoppedThread: 1,
|
||||
selectedThread: 1,
|
||||
threads: [
|
||||
{ id: 1, name: "MainThread" },
|
||||
{ id: 2, name: "Order worker" },
|
||||
],
|
||||
selectedFrame: 1,
|
||||
frames: Array.from({ length: 32 }, (_, index) => ({
|
||||
id: index + 1,
|
||||
name: index === 0 ? functionName : index === 1 ? "runBatch" : `reconcile(${index})`,
|
||||
path: sourcePath,
|
||||
line: index === 0 ? 41 : index,
|
||||
column: 0,
|
||||
presentationHint: null,
|
||||
})),
|
||||
});
|
||||
moveToolWindow("debug", "right");
|
||||
setToolWindowSize("right", 420);
|
||||
toolWindowService().show("debug", true);
|
||||
},
|
||||
{ functionName, sourcePath },
|
||||
);
|
||||
const debug = page.getByRole("region", { name: "Debug", exact: true });
|
||||
await debug.getByRole("tab", { name: "Threads & Variables", exact: true }).click();
|
||||
const thread = debug.getByRole("button", { name: "Thread", exact: true });
|
||||
const frames = debug.getByRole("listbox", { name: "Frames", exact: true });
|
||||
const first = frames.getByRole("option", { selected: true });
|
||||
await expect(first.getByText(functionName, { exact: true })).toBeVisible();
|
||||
expect(await frames.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await expect(first.getByText(":42", { exact: true })).toBeInViewport({ ratio: 1 });
|
||||
expect(await first.getByText(/build\.gradle\.kts/).evaluate((el) => el.clientWidth)).toBeGreaterThan(25);
|
||||
const shortName = frames.getByText("runBatch", { exact: true });
|
||||
expect(await shortName.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
|
||||
await frames.focus();
|
||||
for (let i = 0; i < 25; i++) await page.keyboard.press("ArrowDown");
|
||||
const selected = frames.getByRole("option", { selected: true });
|
||||
await expect(selected.getByText("reconcile(25)", { exact: true })).toBeInViewport({ ratio: 0.95 });
|
||||
expect(await frames.evaluate((el) => el.scrollTop)).toBeGreaterThan(0);
|
||||
|
||||
await thread.click();
|
||||
await page.getByRole("option", { name: "Order worker", exact: true }).click();
|
||||
await expect(thread).toContainText("Order worker");
|
||||
await expect(frames.getByRole("option", { selected: true })).toContainText("processOrder");
|
||||
});
|
||||
@@ -0,0 +1,63 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
const amountName = "regionalSettlementAmountFromExternalProcessorBeforeRounding";
|
||||
const routingName = "settlementRoutingReferenceForCrossBorderReconciliation";
|
||||
const routingValue = "'APR-2026 / eu-west / batch-701 / settlement complete'";
|
||||
|
||||
test("keeps values and their full-value action readable in a narrow debugger", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1220, height: 760 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ amountName, routingName, routingValue }) => {
|
||||
const debugModule = "/src/features/debugger/state.ts";
|
||||
const layoutModule = "/src/workbench/toolwindows/store.ts";
|
||||
const servicesModule = "/src/workbench/contributions.ts";
|
||||
const { adoptSession } = await import(/* @vite-ignore */ debugModule);
|
||||
const { moveToolWindow, setToolWindowSize } = await import(/* @vite-ignore */ layoutModule);
|
||||
const { toolWindowService } = await import(/* @vite-ignore */ servicesModule);
|
||||
const h = window.__ipc.handlers;
|
||||
h.debug_scopes = () => [{ name: "Locals", variablesReference: 100, expensive: false }];
|
||||
h.debug_variables = () => [
|
||||
{ name: amountName, value: "47.74", typeName: "float", variablesReference: 0, evaluateName: amountName },
|
||||
{ name: routingName, value: routingValue, typeName: "str", variablesReference: 0, evaluateName: routingName },
|
||||
];
|
||||
adoptSession(91, {
|
||||
name: "Checkout",
|
||||
adapter: "debugpy",
|
||||
status: "paused",
|
||||
selectedFrame: 11,
|
||||
frames: [{ id: 11, name: "checkout", path: null, line: 0, column: 0, presentationHint: null }],
|
||||
});
|
||||
moveToolWindow("debug", "right");
|
||||
setToolWindowSize("right", 390);
|
||||
toolWindowService().show("debug", true);
|
||||
},
|
||||
{ amountName, routingName, routingValue },
|
||||
);
|
||||
|
||||
const debug = page.getByRole("region", { name: "Debug", exact: true });
|
||||
await debug.getByRole("tab", { name: "Threads & Variables", exact: true }).click();
|
||||
const amount = debug.getByText("47.74", { exact: true });
|
||||
await expect
|
||||
.poll(() => amount.evaluate((el) => el.clientWidth > 0 && el.scrollWidth <= el.clientWidth + 1))
|
||||
.toBe(true);
|
||||
const routing = debug.getByRole("treeitem").filter({ hasText: routingName });
|
||||
const show = routing.getByTitle("Show", { exact: true });
|
||||
await expect(show).toBeInViewport({ ratio: 1 });
|
||||
await show.click();
|
||||
const dialog = page.getByRole("dialog", { name: `Value of ${routingName}` });
|
||||
await expect(dialog.getByText(routingValue, { exact: true })).toBeVisible();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(dialog).toBeHidden();
|
||||
|
||||
await page.setViewportSize({ width: 1640, height: 760 });
|
||||
await page.evaluate(async () => {
|
||||
const layoutModule = "/src/workbench/toolwindows/store.ts";
|
||||
const { moveToolWindow } = await import(/* @vite-ignore */ layoutModule);
|
||||
moveToolWindow("debug", "bottom");
|
||||
});
|
||||
await expect(show).toBeHidden();
|
||||
await expect
|
||||
.poll(() => routing.getByText(routingValue, { exact: true }).evaluate((el) => el.scrollWidth <= el.clientWidth + 1))
|
||||
.toBe(true);
|
||||
});
|
||||
@@ -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,42 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("Editor Font keeps the preview in view while editing and resizing the controls", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1200, height: 760 });
|
||||
await page.keyboard.press("Meta+,");
|
||||
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const search = settings.getByRole("textbox", { name: "Search settings" });
|
||||
await search.fill("Show only monospaced fonts");
|
||||
await settings.getByRole("treeitem", { name: "Font", exact: true, level: 2 }).click();
|
||||
await search.clear();
|
||||
|
||||
const divider = settings.getByRole("separator", { name: "Resize font preview" });
|
||||
const options = settings.getByRole("region", { name: "Font options", exact: true });
|
||||
const preview = settings.getByRole("textbox", { name: "Font preview", exact: true });
|
||||
const font = options.getByRole("combobox", { name: "Font", exact: true });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "vertical");
|
||||
expect((await font.boundingBox())!.x).toBeLessThan((await preview.boundingBox())!.x);
|
||||
await expect.poll(() => preview.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
|
||||
await preview.fill("function main() { return 42; }");
|
||||
await options.getByRole("textbox", { name: "Size", exact: true }).fill("18");
|
||||
await options.getByRole("textbox", { name: "Line height", exact: true }).fill("25");
|
||||
await expect(preview).toHaveCSS("font-size", "18px");
|
||||
await expect(preview).toHaveCSS("line-height", "25px");
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 620 });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
expect((await font.boundingBox())!.y).toBeLessThan((await preview.boundingBox())!.y);
|
||||
await expect(preview).toHaveValue("function main() { return 42; }");
|
||||
const y = (await divider.boundingBox())!.y;
|
||||
await divider.press("ArrowDown");
|
||||
await expect.poll(async () => (await divider.boundingBox())!.y).toBeGreaterThan(y + 1);
|
||||
|
||||
await search.fill("Fallback font");
|
||||
const fallback = options.getByRole("combobox", { name: "Fallback font", exact: true });
|
||||
await fallback.scrollIntoViewIfNeeded();
|
||||
await expect(fallback).toBeInViewport();
|
||||
await fallback.fill("Consolas");
|
||||
await expect(preview).toHaveCSS("font-family", /Consolas/);
|
||||
await expect(preview).toBeInViewport();
|
||||
await expect.poll(() => options.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
});
|
||||
@@ -64,3 +64,15 @@ test("editor Git submenu keeps repository actions disabled without Git", async (
|
||||
}
|
||||
await expect(page.getByRole("menuitem", { name: "Clone…", exact: true })).toBeEnabled();
|
||||
});
|
||||
|
||||
test("Project view Git submenu ends with Manage Remotes and Clone", async ({ workbench: page }) => {
|
||||
await page.getByRole("treeitem", { name: /README\.md/ }).click({ button: "right" });
|
||||
await page.getByRole("menuitem", { name: "Git", exact: true }).hover();
|
||||
const git = page.getByRole("menu").filter({ has: page.getByRole("menuitem", { name: "Clone…", exact: true }) });
|
||||
const items = git.locator('[role="menuitem"], [role="menuitemcheckbox"]');
|
||||
await expect(items.nth(-3)).toHaveText(/Unstash Changes…/);
|
||||
await expect(items.nth(-2)).toHaveText(/Manage Remotes…/);
|
||||
await expect(items.nth(-1)).toHaveText(/Clone…/);
|
||||
await git.getByRole("menuitem", { name: "Manage Remotes…", exact: true }).click();
|
||||
await expect(page.getByRole("dialog", { name: "Git Remotes" })).toBeVisible();
|
||||
});
|
||||
@@ -0,0 +1,90 @@
|
||||
import type { Locator, Page } from "@playwright/test";
|
||||
import { expect, openFromTree, test } from "./fixtures";
|
||||
|
||||
async function setTabs(page: Page, tabs: Record<string, unknown>) {
|
||||
await page.evaluate(async (tabs) => {
|
||||
const projectModule = "/src/platform/project.ts";
|
||||
const { useProject } = await import(/* @vite-ignore */ projectModule);
|
||||
const { settings } = useProject.getState();
|
||||
useProject.setState({
|
||||
settings: { ...settings, editor: { ...settings?.editor, tabs: { ...settings?.editor?.tabs, ...tabs } } },
|
||||
});
|
||||
}, tabs);
|
||||
}
|
||||
|
||||
const box = async (locator: Locator) => (await locator.boundingBox())!;
|
||||
const closeOf = (tab: Locator) => tab.locator("..").getByRole("button", { name: "Close Tab", exact: true });
|
||||
|
||||
test("a close button on the right keeps a narrow slot on every tab", async ({ workbench: page }) => {
|
||||
await openFromTree(page, "README.md");
|
||||
await openFromTree(page, "build.gradle.kts");
|
||||
const strip = page.getByRole("tablist", { name: "Editor tabs" });
|
||||
const idle = strip.getByRole("tab", { name: "README.md" });
|
||||
const label = await box(idle.locator(":scope > span"));
|
||||
const idleTab = await box(idle.locator(".."));
|
||||
expect(idleTab.x + idleTab.width - (label.x + label.width)).toBeCloseTo(18, 0);
|
||||
|
||||
const selected = strip.getByRole("tab", { name: "build.gradle.kts" });
|
||||
const close = await box(closeOf(selected));
|
||||
const tab = await box(selected.locator(".."));
|
||||
const text = await box(selected.locator(":scope > span"));
|
||||
expect(close.x).toBeGreaterThanOrEqual(text.x + text.width - 0.5);
|
||||
expect(close.x + close.width).toBeLessThanOrEqual(tab.x + tab.width + 0.5);
|
||||
expect(tab.x - (idleTab.x + idleTab.width)).toBeCloseTo(4, 0);
|
||||
});
|
||||
|
||||
for (const closeButtonPosition of ["right", "left"]) {
|
||||
test(`a dragged tab's ghost keeps the tab's layout, close button ${closeButtonPosition}`, async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await openFromTree(page, "README.md");
|
||||
await openFromTree(page, "build.gradle.kts");
|
||||
await setTabs(page, { closeButtonPosition });
|
||||
const selected = page.getByRole("tablist", { name: "Editor tabs" }).getByRole("tab", { name: "build.gradle.kts" });
|
||||
const tab = await box(selected.locator(".."));
|
||||
const close = await box(closeOf(selected));
|
||||
await page.mouse.move(tab.x + tab.width / 2, tab.y + tab.height / 2);
|
||||
await page.mouse.down();
|
||||
await page.mouse.move(tab.x + tab.width / 2, tab.y + tab.height / 2 + 40, { steps: 4 });
|
||||
const ghost = page.locator('[aria-hidden="true"]:has([data-tab-close])');
|
||||
const copy = await box(ghost);
|
||||
const copyClose = await box(ghost.locator("[data-tab-close] button"));
|
||||
expect(copy.width).toBeCloseTo(tab.width, 0);
|
||||
expect(copyClose.x - copy.x).toBeCloseTo(close.x - tab.x, 0);
|
||||
expect(copyClose.x + copyClose.width).toBeLessThanOrEqual(copy.x + copy.width + 0.5);
|
||||
await page.keyboard.press("Escape");
|
||||
await page.mouse.up();
|
||||
await expect(ghost).toHaveCount(0);
|
||||
});
|
||||
}
|
||||
|
||||
test("a close button on the left keeps a narrow slot before the icon", async ({ workbench: page }) => {
|
||||
await openFromTree(page, "README.md");
|
||||
await openFromTree(page, "build.gradle.kts");
|
||||
await setTabs(page, { closeButtonPosition: "left" });
|
||||
const strip = page.getByRole("tablist", { name: "Editor tabs" });
|
||||
|
||||
// The selected and the hovered tab show their button in an 18px slot before the icon, which stays visible.
|
||||
const selected = strip.getByRole("tab", { name: "build.gradle.kts" });
|
||||
const other = strip.getByRole("tab", { name: "README.md" });
|
||||
await other.hover();
|
||||
for (const tab of [selected, other]) {
|
||||
const icon = tab.locator(":scope > :first-child");
|
||||
await expect(icon).toHaveCSS("opacity", "1");
|
||||
await expect(closeOf(tab)).toHaveCSS("opacity", "1");
|
||||
const slot = await box(tab.locator(".."));
|
||||
const close = await box(closeOf(tab));
|
||||
const glyph = await box(icon);
|
||||
const label = await box(tab.locator(":scope > span"));
|
||||
expect(close.x + close.width).toBeLessThanOrEqual(glyph.x + 0.5);
|
||||
expect(glyph.x - slot.x).toBeCloseTo(18, 0);
|
||||
expect(slot.x + slot.width - (label.x + label.width)).toBeCloseTo(8, 0);
|
||||
}
|
||||
|
||||
// Without file icons the close button keeps its own place before the label.
|
||||
await setTabs(page, { showFileIcon: false });
|
||||
await expect(selected.locator("svg, img")).toHaveCount(0);
|
||||
const label = await box(selected.locator(":scope > span"));
|
||||
const slot = await box(closeOf(selected));
|
||||
expect(slot.x + slot.width).toBeLessThanOrEqual(label.x + 0.5);
|
||||
});
|
||||
@@ -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,86 @@
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
const root = "/dev/acme-api";
|
||||
const name = `InternationalSettlement${"Reconciliation".repeat(10)}.txt`;
|
||||
const destination = `archive/Approved${"Settlement".repeat(11)}`;
|
||||
|
||||
test("keeps a long source name and destination readable while moving a file", async ({ workbench: page }) => {
|
||||
await page.evaluate(
|
||||
async ({ root, name, destination }) => {
|
||||
const fsModule = "/src/features/project-tree/fs.ts";
|
||||
const { projectFs } = await import(/* @vite-ignore */ fsModule);
|
||||
const storeModule = "/src/features/project-tree/store.ts";
|
||||
const { loadDir } = await import(/* @vite-ignore */ storeModule);
|
||||
const fs = projectFs(root);
|
||||
await fs.createFile(`${root}/${name}`);
|
||||
await fs.createDir(`${root}/archive`);
|
||||
await fs.createDir(`${root}/${destination}`);
|
||||
await loadDir(root, true);
|
||||
},
|
||||
{ root, name, destination },
|
||||
);
|
||||
await page.getByRole("treeitem", { name, exact: true }).click();
|
||||
await page.keyboard.press("F6");
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Move", exact: true });
|
||||
const field = dialog.getByRole("textbox", { name: "Target directory" });
|
||||
await expect(field).toBeFocused();
|
||||
await page.setViewportSize({ width: 470, height: 480 });
|
||||
await expect
|
||||
.poll(() => dialog.locator("[data-dialog-body]").evaluate((el) => el.scrollWidth - el.clientWidth))
|
||||
.toBeLessThanOrEqual(1);
|
||||
expect(
|
||||
await field.evaluate((el: HTMLInputElement) => el.value.slice(el.selectionStart ?? 0, el.selectionEnd ?? 0)),
|
||||
).toBe("acme-api");
|
||||
const submit = dialog.getByRole("button", { name: "Refactor", exact: true });
|
||||
await expect(submit).toBeDisabled();
|
||||
await field.fill(destination);
|
||||
await expect(dialog.getByText(destination, { exact: true })).toBeVisible();
|
||||
await expect(submit).toBeInViewport({ ratio: 1 });
|
||||
await dialog.getByRole("checkbox", { name: "Search for references" }).uncheck();
|
||||
await dialog.getByRole("checkbox", { name: "Search in comments and strings" }).uncheck();
|
||||
await submit.click();
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(
|
||||
async ({ root, destination }) => {
|
||||
const fsModule = "/src/features/project-tree/fs.ts";
|
||||
const { projectFs } = await import(/* @vite-ignore */ fsModule);
|
||||
return (await projectFs(root).readDir(`${root}/${destination}`)).map((entry: { name: string }) => entry.name);
|
||||
},
|
||||
{ root, destination },
|
||||
),
|
||||
)
|
||||
.toEqual([name]);
|
||||
});
|
||||
|
||||
test("browses for a destination and keeps the current path on cancel", async ({ workbench: page }) => {
|
||||
await page.getByRole("treeitem", { name: "README.md", exact: true }).click();
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(() => {
|
||||
window.__ipc.handlers.file_dialog_needs_gtk = () => false;
|
||||
let chosen: string | null = null;
|
||||
window.__ipc.handlers["plugin:dialog|open"] = () => {
|
||||
const result = chosen;
|
||||
chosen = "C:\\Projects\\Invoice Archive";
|
||||
return result;
|
||||
};
|
||||
});
|
||||
await page.keyboard.press("F6");
|
||||
const dialog = page.getByRole("dialog", { name: "Move", exact: true });
|
||||
const field = dialog.getByRole("textbox", { name: "Target directory" });
|
||||
const browse = dialog.getByRole("button", { name: "Browse for target directory", exact: true });
|
||||
await browse.click();
|
||||
await expect.poll(() => ipcCalls(page, "plugin:dialog|open")).toHaveLength(1);
|
||||
await expect(field).toHaveValue(root);
|
||||
await browse.click();
|
||||
await expect(field).toHaveValue("C:/Projects/Invoice Archive");
|
||||
await expect(dialog.getByRole("button", { name: "Refactor", exact: true })).toBeEnabled();
|
||||
await field.fill("C:/");
|
||||
await expect(dialog.getByText("C:/", { exact: true })).toBeVisible();
|
||||
await field.fill("/");
|
||||
await expect(dialog.getByText("/", { exact: true })).toBeVisible();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(dialog).toBeHidden();
|
||||
});
|
||||
@@ -0,0 +1,62 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("File Types keeps association editors usable and opens ignored rules from search", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1120, height: 760 });
|
||||
await page.keyboard.press("Meta+,");
|
||||
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await expect(settings).toBeVisible();
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(() => {
|
||||
window.__ipc.handlers.languages = () => [
|
||||
{ id: "javascript", name: "JavaScript", extensions: ["js"] },
|
||||
{ id: "python", name: "Python", extensions: ["py", "pyi", "pyw"], filenames: ["SConstruct", "SConscript"] },
|
||||
];
|
||||
});
|
||||
const search = settings.getByRole("textbox", { name: "Search settings" });
|
||||
await search.fill("File Types");
|
||||
await settings.getByRole("treeitem", { name: "File Types", exact: true }).click();
|
||||
await search.clear();
|
||||
|
||||
const tabs = settings.getByRole("tablist", { name: "File Types" });
|
||||
const recognized = tabs.getByRole("tab", { name: "Recognized File Types" });
|
||||
const ignored = tabs.getByRole("tab", { name: "Ignored Files and Folders" });
|
||||
await expect(recognized).toHaveAttribute("aria-selected", "true");
|
||||
const divider = settings.getByRole("separator", { name: "Resize file type panes" });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "vertical");
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 660 });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
const types = settings.getByRole("listbox", { name: "Recognized file types", exact: true });
|
||||
await types.getByRole("option", { name: "Python", exact: true }).click();
|
||||
const patterns = settings.getByRole("listbox", { name: "File name patterns of Python" });
|
||||
const hashbangLabel = settings.getByText("Hashbang patterns", { exact: true });
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const nameList = await patterns.boundingBox();
|
||||
const hashbangHeading = await hashbangLabel.boundingBox();
|
||||
return nameList && hashbangHeading ? hashbangHeading.y - (nameList.y + nameList.height) : -1;
|
||||
})
|
||||
.toBeGreaterThan(0);
|
||||
await expect
|
||||
.poll(() => settings.locator("[class*='_patterns_']").evaluate((el) => el.scrollWidth - el.clientWidth))
|
||||
.toBeLessThanOrEqual(1);
|
||||
const toolbar = settings.locator(`[role="toolbar"][aria-controls="${await patterns.getAttribute("id")}"]`);
|
||||
await toolbar.getByRole("button", { name: "Add" }).click();
|
||||
const pattern = patterns.getByRole("textbox", { name: "Pattern" });
|
||||
await pattern.fill("*.layout-demo");
|
||||
await pattern.press("Enter");
|
||||
await expect(patterns.getByRole("option", { name: "*.layout-demo", exact: true })).toBeVisible();
|
||||
await expect
|
||||
.poll(() => settings.locator("[class*='pageBody']").evaluate((el) => el.scrollWidth - el.clientWidth))
|
||||
.toBeLessThanOrEqual(1);
|
||||
|
||||
await search.fill("Exclude patterns");
|
||||
await expect(ignored).toHaveAttribute("aria-selected", "true");
|
||||
await expect(settings.getByRole("listbox", { name: "Exclude patterns" })).toBeVisible();
|
||||
await expect(patterns).toBeHidden();
|
||||
await ignored.click();
|
||||
await search.clear();
|
||||
await ignored.press("ArrowLeft");
|
||||
await expect(recognized).toHaveAttribute("aria-selected", "true");
|
||||
await expect(patterns.getByRole("option", { name: "*.layout-demo", exact: true })).toBeVisible();
|
||||
});
|
||||
@@ -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();
|
||||
});
|
||||
Loaded 100 of 531 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача