дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-22 17:40:45 +02:00
Порівняти коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
ad7d87710c |
No files matched your search
Створено
-18
@@ -4156,8 +4156,6 @@ dependencies = [
|
||||
"ide-vcs",
|
||||
"ide-vfs",
|
||||
"parking_lot",
|
||||
"rustix",
|
||||
"semver",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"specta",
|
||||
@@ -4359,20 +4357,6 @@ dependencies = [
|
||||
"which",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-drag-out"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"gtk",
|
||||
"objc2 0.6.5",
|
||||
"objc2-app-kit 0.3.2",
|
||||
"objc2-foundation 0.3.2",
|
||||
"raw-window-handle",
|
||||
"tempfile",
|
||||
"windows",
|
||||
"windows-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-extension"
|
||||
version = "0.1.49"
|
||||
@@ -4527,7 +4511,6 @@ dependencies = [
|
||||
name = "ide-http"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"hyper-util",
|
||||
"ide-core",
|
||||
"ide-vfs",
|
||||
"parking_lot",
|
||||
@@ -6714,7 +6697,6 @@ dependencies = [
|
||||
"ide-dap",
|
||||
"ide-db",
|
||||
"ide-docker",
|
||||
"ide-drag-out",
|
||||
"ide-extension",
|
||||
"ide-fonts",
|
||||
"ide-github",
|
||||
|
||||
@@ -38,7 +38,6 @@ ide-web = { path = "crates/ide-web" }
|
||||
ide-spell = { path = "crates/ide-spell" }
|
||||
ide-agent = { path = "crates/ide-agent" }
|
||||
ide-clipboard = { path = "crates/ide-clipboard" }
|
||||
ide-drag-out = { path = "crates/ide-drag-out" }
|
||||
ide-fonts = { path = "crates/ide-fonts" }
|
||||
ide-ssh = { path = "crates/ide-ssh" }
|
||||
ide-remote = { path = "crates/ide-remote" }
|
||||
|
||||
@@ -25,10 +25,6 @@ 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"] }
|
||||
@@ -1,395 +0,0 @@
|
||||
//! 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,7 +10,6 @@
|
||||
mod acp;
|
||||
mod async_questions;
|
||||
mod catalogs;
|
||||
mod cli_update;
|
||||
mod config;
|
||||
mod conversation;
|
||||
mod elicitation;
|
||||
@@ -28,7 +27,6 @@ mod timeline;
|
||||
mod worktree;
|
||||
|
||||
pub use catalogs::AgentCatalogs;
|
||||
pub use cli_update::{AgentCliOffer, AgentCliUpdateResult};
|
||||
pub use external::ExternalSession;
|
||||
pub use model::*;
|
||||
|
||||
@@ -143,7 +141,7 @@ struct Shared {
|
||||
paths: AgentPaths,
|
||||
runtime: tokio::runtime::Handle,
|
||||
connector: Connector,
|
||||
sinks: RwLock<HashMap<String, AgentSink>>,
|
||||
sink: RwLock<Option<AgentSink>>,
|
||||
security: RwLock<Option<SecurityHook>>,
|
||||
new_task_approvals: RwLock<Option<NewTaskApprovalsHook>>,
|
||||
known: Arc<Mutex<HashMap<String, Known>>>,
|
||||
@@ -215,12 +213,10 @@ impl Shared {
|
||||
}
|
||||
|
||||
fn emit(&self, event: AgentEvent) {
|
||||
let mut sinks: Vec<_> = self.sinks.read().values().cloned().collect();
|
||||
let Some(last) = sinks.pop() else { return };
|
||||
for sink in sinks {
|
||||
sink(event.clone());
|
||||
let sink = self.sink.read().clone();
|
||||
if let Some(sink) = sink {
|
||||
sink(event);
|
||||
}
|
||||
last(event);
|
||||
}
|
||||
|
||||
/// The MCP servers passed to a session, and the names of the ones off for it.
|
||||
@@ -565,7 +561,7 @@ impl AgentManager {
|
||||
paths,
|
||||
runtime,
|
||||
connector,
|
||||
sinks: RwLock::new(HashMap::new()),
|
||||
sink: RwLock::new(None),
|
||||
security: RwLock::new(None),
|
||||
new_task_approvals: RwLock::new(None),
|
||||
known,
|
||||
@@ -608,22 +604,12 @@ impl AgentManager {
|
||||
|
||||
/// Routes events to `sink` (replacing the previous subscriber); returns every task.
|
||||
pub fn subscribe(&self, sink: AgentSink) -> Vec<AgentTask> {
|
||||
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);
|
||||
*self.shared.sink.write() = Some(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);
|
||||
@@ -2014,7 +2000,7 @@ impl AgentManager {
|
||||
// What arrived after the last save (a subagent's late updates).
|
||||
task.persist();
|
||||
}
|
||||
self.shared.sinks.write().clear();
|
||||
*self.shared.sink.write() = None;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -614,9 +614,6 @@ pub struct AgentProvider {
|
||||
pub command_read_only_reason: Option<AgentCommandReadOnlyReason>,
|
||||
/// Whether the command was found (on `PATH`).
|
||||
pub installed: bool,
|
||||
/// The built-in command can be owned by a global npm package.
|
||||
#[serde(default)]
|
||||
pub can_check_cli_update: bool,
|
||||
/// Environment variables it starts with (from its agent file).
|
||||
pub env: BTreeMap<String, String>,
|
||||
/// Settings (models, modes…) the agent offered last time it ran; empty before its first session.
|
||||
|
||||
@@ -373,7 +373,6 @@ pub(crate) fn describe(spec: &ProviderSpec) -> AgentProvider {
|
||||
command_editable: reason.is_none(),
|
||||
command_read_only_reason: reason,
|
||||
installed: installed(&spec.command),
|
||||
can_check_cli_update: spec.source == AgentSource::Builtin && crate::cli_update::package(&spec.id).is_some(),
|
||||
env: spec.env.iter().cloned().collect(),
|
||||
config: vec![],
|
||||
thought_levels: BTreeMap::new(),
|
||||
|
||||
@@ -452,35 +452,6 @@ fn manager(dir: &Path, agent: Arc<FakeAgent>) -> AgentManager {
|
||||
manager_at(dir, &dir.join("models.json"), agent)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn subscribers_do_not_replace_or_close_each_other() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let main = Arc::new(Mutex::new(Vec::new()));
|
||||
let child = Arc::new(Mutex::new(Vec::new()));
|
||||
let subscribe = |window: &str, events: &Arc<Mutex<Vec<AgentEvent>>>| {
|
||||
let events = events.clone();
|
||||
mgr.subscribe_as(window, Arc::new(move |event| events.lock().push(event)));
|
||||
};
|
||||
subscribe("main", &main);
|
||||
subscribe("editor-main-1", &child);
|
||||
mgr.shared.emit(AgentEvent::Providers);
|
||||
assert_eq!(main.lock().len(), 1);
|
||||
assert_eq!(child.lock().len(), 1);
|
||||
// A reloaded webview replaces only its own old channel.
|
||||
let reloaded = Arc::new(Mutex::new(Vec::new()));
|
||||
subscribe("editor-main-1", &reloaded);
|
||||
mgr.shared.emit(AgentEvent::Providers);
|
||||
assert_eq!(main.lock().len(), 2);
|
||||
assert_eq!(child.lock().len(), 1);
|
||||
assert_eq!(reloaded.lock().len(), 1);
|
||||
mgr.unsubscribe("editor-main-1");
|
||||
mgr.shared.emit(AgentEvent::Providers);
|
||||
assert_eq!(main.lock().len(), 3);
|
||||
assert_eq!(reloaded.lock().len(), 1);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
fn manager_at(dir: &Path, models_file: &Path, agent: Arc<FakeAgent>) -> AgentManager {
|
||||
// These tests speak to FakeAgent, never an installed CLI, including after a provider reload.
|
||||
let agents = dir.join("agents");
|
||||
|
||||
@@ -197,7 +197,6 @@ pub enum ImportsOnPaste {
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct FoldingSettings {
|
||||
pub show_outline: bool,
|
||||
pub outline_visibility: FoldingOutlineVisibility,
|
||||
pub file_header: bool,
|
||||
pub imports: bool,
|
||||
pub doc_comments: bool,
|
||||
@@ -205,24 +204,10 @@ pub struct FoldingSettings {
|
||||
|
||||
impl Default for FoldingSettings {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
show_outline: true,
|
||||
outline_visibility: FoldingOutlineVisibility::Hover,
|
||||
file_header: true,
|
||||
imports: true,
|
||||
doc_comments: false,
|
||||
}
|
||||
Self { show_outline: true, file_header: true, imports: true, doc_comments: false }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum FoldingOutlineVisibility {
|
||||
#[default]
|
||||
Hover,
|
||||
Always,
|
||||
}
|
||||
|
||||
/// Editor › General › Editor Tabs.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
@@ -558,24 +543,3 @@ mod auto_import_tests {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod folding_tests {
|
||||
use super::{FoldingOutlineVisibility, FoldingSettings};
|
||||
|
||||
#[test]
|
||||
fn folding_outline_defaults_to_hover_for_existing_settings() {
|
||||
let settings: FoldingSettings = serde_json::from_str(r#"{"showOutline":false}"#).unwrap();
|
||||
assert!(!settings.show_outline);
|
||||
assert_eq!(settings.outline_visibility, FoldingOutlineVisibility::Hover);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn folding_outline_visibility_round_trips() {
|
||||
for mode in ["hover", "always"] {
|
||||
let json = serde_json::json!({ "outlineVisibility": mode });
|
||||
let settings: FoldingSettings = serde_json::from_value(json).unwrap();
|
||||
assert_eq!(serde_json::to_value(settings).unwrap()["outlineVisibility"], mode);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -15,7 +15,6 @@ 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;
|
||||
|
||||
@@ -1,20 +0,0 @@
|
||||
//! Returning freed heap pages to the OS.
|
||||
|
||||
/// Hands pages the allocator has freed but kept back to the OS. Call after a burst of
|
||||
/// short-lived allocations (a full index scan); until then they still count towards the
|
||||
/// process's memory footprint.
|
||||
pub fn release_free_pages() {
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
unsafe extern "C" {
|
||||
fn malloc_zone_pressure_relief(zone: *mut std::ffi::c_void, goal: usize) -> usize;
|
||||
}
|
||||
// SAFETY: a null zone covers every zone; a zero goal releases as much as possible.
|
||||
unsafe { malloc_zone_pressure_relief(std::ptr::null_mut(), 0) };
|
||||
}
|
||||
#[cfg(all(target_os = "linux", target_env = "gnu"))]
|
||||
// SAFETY: malloc_trim only returns free memory to the OS.
|
||||
unsafe {
|
||||
libc::malloc_trim(0);
|
||||
}
|
||||
}
|
||||
@@ -11,8 +11,6 @@ use std::collections::BTreeMap;
|
||||
pub struct VcsSettings {
|
||||
/// Colour folders that contain changed files (project tree, tabs).
|
||||
pub show_dirty_directories: bool,
|
||||
/// Diffs the user opens show in an editor tab; off, in a separate window.
|
||||
pub diff_as_editor_tab: bool,
|
||||
/// Stop file history (Show History) after `history_limit` commits.
|
||||
pub limit_history: bool,
|
||||
pub history_limit: u32,
|
||||
@@ -57,7 +55,6 @@ impl Default for VcsSettings {
|
||||
Self {
|
||||
// IDEA's VcsConfiguration.SHOW_DIRTY_RECURSIVELY is off by default.
|
||||
show_dirty_directories: false,
|
||||
diff_as_editor_tab: true,
|
||||
limit_history: true,
|
||||
history_limit: 1000,
|
||||
git: GitSettings::default(),
|
||||
|
||||
@@ -49,8 +49,6 @@ pub struct AdapterSpec {
|
||||
pub connect: Option<String>,
|
||||
/// A plugin language's adapter: start exactly this approved program.
|
||||
pub pinned: Option<ProgramPin>,
|
||||
/// See [`DebuggerConfig::resolve_lazy_variables`].
|
||||
pub resolve_lazy_variables: bool,
|
||||
}
|
||||
|
||||
/// Built-in adapters used when no language definition names `adapter`.
|
||||
@@ -62,7 +60,6 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
|
||||
transport: transport.to_owned(),
|
||||
connect: None,
|
||||
install_hint: Some(hint.to_owned()),
|
||||
resolve_lazy_variables: false,
|
||||
pinned: None,
|
||||
};
|
||||
Some(match adapter {
|
||||
@@ -133,15 +130,12 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
|
||||
),
|
||||
"rdbg" => cfg("rdbg", &["-O", "--port", PORT_PLACEHOLDER, "-c"], "tcp", "gem install debug"),
|
||||
// A jdtls bundle: the session is started through jdtls and reached via `debugServer`.
|
||||
"java-debug" => DebuggerConfig {
|
||||
resolve_lazy_variables: true,
|
||||
..cfg(
|
||||
"com.microsoft.java.debug.plugin.jar",
|
||||
&[],
|
||||
"tcp",
|
||||
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
|
||||
)
|
||||
},
|
||||
"java-debug" => cfg(
|
||||
"com.microsoft.java.debug.plugin.jar",
|
||||
&[],
|
||||
"tcp",
|
||||
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
|
||||
),
|
||||
// The Java language server's own debugger, for modules jdtls doesn't serve; the host
|
||||
// runs the executable of the java-analyzer serving the module.
|
||||
JAVA_ANALYZER => cfg(
|
||||
@@ -192,7 +186,6 @@ pub fn resolve(config: &DebuggerConfig, cwd: PathBuf) -> AdapterSpec {
|
||||
server_host: None,
|
||||
connect: config.connect.clone(),
|
||||
pinned: config.pinned.clone(),
|
||||
resolve_lazy_variables: config.resolve_lazy_variables,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -102,7 +102,6 @@ pub(crate) fn bare_session_of(name: &str, request: &str) -> BareSession {
|
||||
server_host: None,
|
||||
connect: None,
|
||||
pinned: None,
|
||||
resolve_lazy_variables: false,
|
||||
};
|
||||
let session = Session::new(
|
||||
DebugSessionId(1),
|
||||
|
||||
@@ -236,11 +236,6 @@ pub struct Variable {
|
||||
/// > 0 when expandable.
|
||||
pub variables_reference: i64,
|
||||
pub evaluate_name: Option<String>,
|
||||
/// `value` is not computed yet (DAP `presentationHint.lazy`): the single variable that
|
||||
/// `variables` returns for `variables_reference` holds the value and its children.
|
||||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||||
#[specta(optional)]
|
||||
pub lazy: bool,
|
||||
}
|
||||
|
||||
/// A completion the adapter offers for an expression (DAP `completions`).
|
||||
@@ -732,46 +727,9 @@ pub(crate) fn variable_from(v: &Value) -> Variable {
|
||||
type_name: s("type").filter(|t| !t.is_empty()),
|
||||
variables_reference: v.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
|
||||
evaluate_name: s("evaluateName"),
|
||||
lazy: v.pointer("/presentationHint/lazy").and_then(Value::as_bool).unwrap_or(false),
|
||||
}
|
||||
}
|
||||
|
||||
async fn session_variables(session: &Session, reference: i64) -> IdeResult<Vec<Variable>> {
|
||||
let body =
|
||||
session.conn.request_timeout("variables", json!({ "variablesReference": reference }), REQUEST_TIMEOUT).await?;
|
||||
Ok(body
|
||||
.get("variables")
|
||||
.and_then(Value::as_array)
|
||||
.map(|v| v.iter().map(variable_from).collect())
|
||||
.unwrap_or_default())
|
||||
}
|
||||
|
||||
async fn resolve_in(session: &Session, variable: Variable) -> IdeResult<Variable> {
|
||||
if !variable.lazy || variable.variables_reference <= 0 {
|
||||
return Ok(variable);
|
||||
}
|
||||
let mut inner = session_variables(session, variable.variables_reference).await?;
|
||||
Ok(match (inner.pop(), inner.is_empty()) {
|
||||
(Some(value), true) => Variable {
|
||||
type_name: value.type_name.or(variable.type_name),
|
||||
evaluate_name: variable.evaluate_name.or(value.evaluate_name),
|
||||
name: variable.name,
|
||||
value: value.value,
|
||||
variables_reference: value.variables_reference,
|
||||
lazy: value.lazy,
|
||||
},
|
||||
_ => variable,
|
||||
})
|
||||
}
|
||||
|
||||
/// A value that cannot be computed stays lazy, so the row can still be opened by hand.
|
||||
async fn resolve_lazy(session: &Session, variable: Variable) -> Variable {
|
||||
if !variable.lazy {
|
||||
return variable;
|
||||
}
|
||||
resolve_in(session, variable.clone()).await.unwrap_or(variable)
|
||||
}
|
||||
|
||||
impl DebugManager {
|
||||
pub fn new(languages: Arc<LanguageRegistry>) -> Arc<Self> {
|
||||
Self::with_launcher(languages, Arc::new(ProcessLauncher))
|
||||
@@ -1539,7 +1497,6 @@ impl DebugManager {
|
||||
type_name: body.get("type").and_then(Value::as_str).filter(|t| !t.is_empty()).map(str::to_owned),
|
||||
variables_reference: body.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
|
||||
evaluate_name: evaluate_name.or(Some(name)),
|
||||
lazy: false,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -1610,18 +1567,16 @@ impl DebugManager {
|
||||
}
|
||||
|
||||
pub async fn variables(&self, s: DebugSessionId, reference: i64) -> IdeResult<Vec<Variable>> {
|
||||
let session = self.session(s)?;
|
||||
let vars = session_variables(&session, reference).await?;
|
||||
if !session.spec.resolve_lazy_variables {
|
||||
return Ok(vars);
|
||||
}
|
||||
Ok(join_all(vars.into_iter().map(|v| resolve_lazy(&session, v))).await)
|
||||
}
|
||||
|
||||
/// Computes a lazy variable's value (DAP `presentationHint.lazy`); any other variable, or one
|
||||
/// whose value the adapter does not give as a single variable, comes back unchanged.
|
||||
pub async fn resolve_variable(&self, s: DebugSessionId, variable: Variable) -> IdeResult<Variable> {
|
||||
resolve_in(&*self.session(s)?, variable).await
|
||||
let body = self
|
||||
.session(s)?
|
||||
.conn
|
||||
.request_timeout("variables", json!({ "variablesReference": reference }), REQUEST_TIMEOUT)
|
||||
.await?;
|
||||
Ok(body
|
||||
.get("variables")
|
||||
.and_then(Value::as_array)
|
||||
.map(|v| v.iter().map(variable_from).collect())
|
||||
.unwrap_or_default())
|
||||
}
|
||||
|
||||
/// Evaluates in the `repl` context.
|
||||
@@ -1647,18 +1602,13 @@ impl DebugManager {
|
||||
args["frameId"] = f.into();
|
||||
}
|
||||
let body = session.conn.request_timeout("evaluate", args, REQUEST_TIMEOUT).await?;
|
||||
let result = Variable {
|
||||
Ok(Variable {
|
||||
name: expression.clone(),
|
||||
value: body.get("result").and_then(Value::as_str).unwrap_or_default().to_owned(),
|
||||
type_name: body.get("type").and_then(Value::as_str).filter(|t| !t.is_empty()).map(str::to_owned),
|
||||
variables_reference: body.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
|
||||
evaluate_name: Some(expression),
|
||||
lazy: body.pointer("/presentationHint/lazy").and_then(Value::as_bool).unwrap_or(false),
|
||||
};
|
||||
if !session.spec.resolve_lazy_variables {
|
||||
return Ok(result);
|
||||
}
|
||||
Ok(resolve_lazy(&session, result).await)
|
||||
})
|
||||
}
|
||||
|
||||
/// Completions for `text` at `line` / `column` (0-based, UTF-16) in the frame's scope; none
|
||||
@@ -1763,7 +1713,7 @@ impl DebugManager {
|
||||
// A step runs its thread; other threads stopped by their own events stay stopped.
|
||||
session.suspended.resumed(ticket, thread_id, false);
|
||||
stream_trace::release_done(&session);
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: false });
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1875,7 +1825,7 @@ impl DebugManager {
|
||||
step_settled(&session, sent)?;
|
||||
session.suspended.resumed(ticket, thread_id, false);
|
||||
stream_trace::release_done(&session);
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: false });
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
@@ -505,29 +505,13 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
"scopes" => {
|
||||
ok!(msg, json!({"scopes": [{"name": "Locals", "variablesReference": 100, "expensive": false}]}))
|
||||
}
|
||||
// 200 holds a lazy value (java-debug's toString(), js-debug's getters): asked for, its
|
||||
// reference answers one nameless child with the value and the reference of its fields.
|
||||
"variables" => match msg["arguments"]["variablesReference"].as_i64() {
|
||||
Some(200) => ok!(
|
||||
msg,
|
||||
json!({"variables": [
|
||||
{"name": "order", "value": "Order@7", "type": "Order", "variablesReference": 201,
|
||||
"evaluateName": "order", "presentationHint": {"lazy": true}},
|
||||
{"name": "n", "value": "2", "type": "int", "variablesReference": 0, "presentationHint": {"lazy": false}},
|
||||
]})
|
||||
),
|
||||
Some(201) => ok!(
|
||||
msg,
|
||||
json!({"variables": [{"name": "", "value": "Order@7 \"Order(1)\"", "variablesReference": 202, "evaluateName": "order"}]})
|
||||
),
|
||||
_ => ok!(
|
||||
msg,
|
||||
json!({"variables": [
|
||||
{"name": "x", "value": "1", "type": "int", "variablesReference": 0},
|
||||
{"name": "req", "value": "{Req}", "type": "Req", "variablesReference": 101, "evaluateName": "req"},
|
||||
]})
|
||||
),
|
||||
},
|
||||
"variables" => ok!(
|
||||
msg,
|
||||
json!({"variables": [
|
||||
{"name": "x", "value": "1", "type": "int", "variablesReference": 0},
|
||||
{"name": "req", "value": "{Req}", "type": "Req", "variablesReference": 101, "evaluateName": "req"},
|
||||
]})
|
||||
),
|
||||
"evaluate" => ok!(msg, json!({"result": "42", "type": "int", "variablesReference": 0})),
|
||||
"completions" => ok!(
|
||||
msg,
|
||||
@@ -2036,7 +2020,6 @@ fn godot_registry(port: u16, command: &str, args: &[&str]) -> Arc<LanguageRegist
|
||||
transport: "tcp".into(),
|
||||
connect: Some(format!("127.0.0.1:{port}")),
|
||||
install_hint: Some("Open the project in the Godot editor".into()),
|
||||
resolve_lazy_variables: false,
|
||||
pinned: None,
|
||||
}),
|
||||
};
|
||||
@@ -2780,53 +2763,6 @@ async fn step_of_one_thread_keeps_the_others_suspended() {
|
||||
assert_eq!(session.suspended.ticket(), ticket + 1);
|
||||
h.manager.step_in_target(id, 7, 1).await.unwrap();
|
||||
assert!(!session.suspended.get());
|
||||
// The UI stays on a thread that is still stopped only when told the step ran one thread.
|
||||
for thread in [7, 8] {
|
||||
let continued =
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Continued { thread_id, .. } if *thread_id == thread)).await;
|
||||
assert!(matches!(continued, DebugEvent::Continued { all_threads_continued: false, .. }), "{continued:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn lazy_variables_are_resolved_when_the_adapter_declares_them_safe() {
|
||||
let h = harness(Script::default());
|
||||
let id = h.start(java_config("launch")).await.unwrap();
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
|
||||
let vars = h.manager.variables(id, 200).await.unwrap();
|
||||
let order = &vars[0];
|
||||
assert_eq!(
|
||||
(order.name.as_str(), order.value.as_str(), order.type_name.as_deref()),
|
||||
("order", "Order@7 \"Order(1)\"", Some("Order"))
|
||||
);
|
||||
assert_eq!((order.variables_reference, order.lazy), (202, false));
|
||||
assert_eq!(order.evaluate_name.as_deref(), Some("order"));
|
||||
assert_eq!((vars[1].name.as_str(), vars[1].lazy), ("n", false));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn lazy_variables_stay_lazy_for_other_adapters() {
|
||||
let h = harness(Script::default());
|
||||
let id = h.start(config()).await.unwrap();
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
|
||||
let vars = h.manager.variables(id, 200).await.unwrap();
|
||||
assert_eq!((vars[0].value.as_str(), vars[0].variables_reference, vars[0].lazy), ("Order@7", 201, true));
|
||||
assert_eq!(requests(&h, "variables").len(), 1, "nothing is computed until asked for");
|
||||
|
||||
let order = h.manager.resolve_variable(id, vars[0].clone()).await.unwrap();
|
||||
assert_eq!((order.name.as_str(), order.value.as_str()), ("order", "Order@7 \"Order(1)\""));
|
||||
assert_eq!((order.variables_reference, order.lazy), (202, false));
|
||||
let n = h.manager.resolve_variable(id, vars[1].clone()).await.unwrap();
|
||||
assert_eq!((n.value.as_str(), requests(&h, "variables").len()), ("2", 2), "only lazy values are computed");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn java_debug_declares_its_lazy_variables_safe_to_resolve() {
|
||||
let languages = LanguageRegistry::load(None).unwrap();
|
||||
for registry in [&languages, &LanguageRegistry::from_configs(Vec::new())] {
|
||||
assert!(adapter::find_config(registry, "java-debug").unwrap().resolve_lazy_variables);
|
||||
assert!(!adapter::find_config(registry, "js-debug").unwrap().resolve_lazy_variables);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
@@ -145,38 +145,30 @@ impl ClickhousePool {
|
||||
let cancel = CancellationToken::new();
|
||||
let initialize = async {
|
||||
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
|
||||
let Some(setting) = rejected_driver_setting(&error) else {
|
||||
if !rejects_driver_setting(&error) {
|
||||
return Err(error);
|
||||
};
|
||||
}
|
||||
if !use_http_session {
|
||||
if setting == "readonly" {
|
||||
return Err(error);
|
||||
}
|
||||
if !source.read_only {
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; enable Read-only for independent queries on a strict read-only server",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Every request still sends readonly=1, regardless of which node answers.
|
||||
pool.0.session.lock().await.strict_read_only = true;
|
||||
pool.execute("SELECT 1", 1, &cancel).await?;
|
||||
} else {
|
||||
// Only rely on the server's write protection after proving strict read-only
|
||||
// in this same named session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// The rejected probe may have opened a session on a different node.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
}
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Retry only the connection probe. Keep relying on the server for write protection
|
||||
// only after verifying strict read-only mode in this same session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// Start the proof in a fresh session: the rejected probe may have left
|
||||
// its id on another replica without applying the configured database.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
// The HTTP database parameter applies to one request. A named session needs
|
||||
@@ -244,7 +236,7 @@ impl ClickhousePool {
|
||||
if !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
|
||||
request = request.query(&[("database", &self.0.database)]);
|
||||
}
|
||||
if self.0.read_only && (session.id.is_none() || !session.strict_read_only) {
|
||||
if self.0.read_only && !session.strict_read_only {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
request
|
||||
@@ -332,7 +324,7 @@ impl ClickhousePool {
|
||||
result
|
||||
}
|
||||
None => {
|
||||
let killed = self.kill(&client, &query_id, &session).await;
|
||||
let killed = self.kill(&client, &query_id).await;
|
||||
match killed {
|
||||
Ok(()) => Err(IdeError::cancelled()),
|
||||
Err(error) => Err(IdeError::new(
|
||||
@@ -344,16 +336,15 @@ impl ClickhousePool {
|
||||
}
|
||||
}
|
||||
|
||||
async fn kill(&self, client: &Client, query_id: &str, session: &Session) -> IdeResult<()> {
|
||||
let mut request = client
|
||||
async fn kill(&self, client: &Client, query_id: &str) -> IdeResult<()> {
|
||||
let response = client
|
||||
.post(self.0.endpoint.clone())
|
||||
.basic_auth(&self.0.user, Some(&self.0.password))
|
||||
.timeout(Duration::from_secs(3));
|
||||
if self.0.read_only && session.id.is_none() {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
let response =
|
||||
request.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")).send().await.map_err(http_error)?;
|
||||
.timeout(Duration::from_secs(3))
|
||||
.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC"))
|
||||
.send()
|
||||
.await
|
||||
.map_err(http_error)?;
|
||||
let status = response.status();
|
||||
let code = response
|
||||
.headers()
|
||||
@@ -560,14 +551,13 @@ fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
|
||||
.map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
|
||||
}
|
||||
|
||||
fn rejected_driver_setting(error: &IdeError) -> Option<&str> {
|
||||
fn rejects_driver_setting(error: &IdeError) -> bool {
|
||||
error
|
||||
.message
|
||||
.split_once(": ")
|
||||
.and_then(|(_, detail)| detail.strip_prefix("Code: 164. DB::Exception: Cannot modify '"))
|
||||
.and_then(|detail| detail.split_once("' setting in readonly mode"))
|
||||
.map(|(name, _)| name)
|
||||
.filter(|&name| {
|
||||
.is_some_and(|(name, _)| {
|
||||
matches!(
|
||||
name,
|
||||
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
|
||||
@@ -963,77 +953,19 @@ mod tests {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn strict_stateless_connections_keep_readonly_on_every_request() {
|
||||
let denied = "Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)";
|
||||
let (port, requests) = server(vec![
|
||||
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", denied),
|
||||
("200 OK", "", ONE),
|
||||
(
|
||||
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
|
||||
for read_only in [false, true] {
|
||||
let (port, requests) = server(vec![(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot execute query in readonly mode. (READONLY)",
|
||||
),
|
||||
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[0]\n[1]\n[2]\n"),
|
||||
])
|
||||
.await;
|
||||
let source = DataSource {
|
||||
database: "fixture_database".into(),
|
||||
read_only: true,
|
||||
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let write = "CREATE TABLE fixture_table (n UInt8) ENGINE=Memory";
|
||||
assert!(pool.execute(write, 1, &cancel).await.unwrap_err().message.contains("Code: 164"));
|
||||
let sql = "SELECT number AS n FROM numbers(3) LIMIT 3";
|
||||
let result = pool.execute(sql, 1, &cancel).await.unwrap();
|
||||
assert_eq!(result.rows, vec![vec![Some("0".into())]]);
|
||||
assert!(result.has_more);
|
||||
let requests = requests.await.unwrap();
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[1].ends_with("SELECT 1"));
|
||||
assert!(requests[2].ends_with(write));
|
||||
assert!(requests[3].ends_with(sql));
|
||||
for (index, request) in requests.iter().enumerate() {
|
||||
let url = request_url(request);
|
||||
for name in ["session_id", "session_check", "session_timeout", "use_http_session"] {
|
||||
assert_eq!(query_value(&url, name), None, "{name}");
|
||||
}
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "database").as_deref(), Some("fixture_database"));
|
||||
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
|
||||
assert_eq!(query_value(&url, "max_result_rows").as_deref(), (index == 0).then_some("2"));
|
||||
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), (index == 0).then_some("break"));
|
||||
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), (index == 0).then_some("1"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_connections_require_readonly_and_only_relax_driver_result_settings() {
|
||||
for (read_only, detail, body) in [
|
||||
(
|
||||
false,
|
||||
"enable Read-only",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
(
|
||||
true,
|
||||
"Cannot modify 'readonly'",
|
||||
"Code: 164. DB::Exception: Cannot modify 'readonly' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
(
|
||||
true,
|
||||
"Cannot modify 'max_threads'",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_threads' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
] {
|
||||
let (port, requests) =
|
||||
server(vec![("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", body)]).await;
|
||||
)])
|
||||
.await;
|
||||
let source =
|
||||
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
|
||||
assert!(error.message.contains(detail), "{}", error.message);
|
||||
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
|
||||
assert!(error.message.contains("use_http_session=false requires per-request"));
|
||||
let requests = requests.await.unwrap();
|
||||
assert_eq!(requests.len(), 1);
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
@@ -1109,7 +1041,7 @@ mod tests {
|
||||
let error = IdeError::invalid(format!(
|
||||
"ClickHouse HTTP 500: Code: {code}. DB::Exception: Cannot modify '{setting}' setting in readonly mode. (READONLY)"
|
||||
));
|
||||
assert_eq!(rejected_driver_setting(&error).is_some(), expected, "{setting}");
|
||||
assert_eq!(rejects_driver_setting(&error), expected, "{setting}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1152,45 +1084,37 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn cancellation_sends_kill_outside_the_busy_session() {
|
||||
for stateless in [false, true] {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let (started, received) = tokio::sync::oneshot::channel();
|
||||
let server = tokio::spawn(async move {
|
||||
let (mut health, _) = listener.accept().await.unwrap();
|
||||
read_request(&mut health).await;
|
||||
reply(&mut health, "200 OK", "", ONE).await;
|
||||
drop(health);
|
||||
let (mut query, _) = listener.accept().await.unwrap();
|
||||
let request = read_request(&mut query).await;
|
||||
started.send(()).unwrap();
|
||||
let (mut kill, _) =
|
||||
tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
|
||||
let kill_request = read_request(&mut kill).await;
|
||||
reply(&mut kill, "200 OK", "", "").await;
|
||||
(request, kill_request)
|
||||
});
|
||||
let source = DataSource {
|
||||
read_only: true,
|
||||
properties: vec![property("use_http_session", if stateless { "false" } else { "true" })],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
|
||||
let cancelled = async {
|
||||
received.await.unwrap();
|
||||
cancel.cancel();
|
||||
};
|
||||
let (result, ()) = tokio::join!(query, cancelled);
|
||||
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
|
||||
let (query, kill) = server.await.unwrap();
|
||||
let query_id = query_value(&request_url(&query), "query_id").unwrap();
|
||||
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
|
||||
let url = request_url(&kill);
|
||||
assert_eq!(query_value(&url, "session_id"), None);
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), stateless.then_some("1"));
|
||||
}
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let (started, received) = tokio::sync::oneshot::channel();
|
||||
let server = tokio::spawn(async move {
|
||||
let (mut health, _) = listener.accept().await.unwrap();
|
||||
read_request(&mut health).await;
|
||||
reply(&mut health, "200 OK", "", ONE).await;
|
||||
drop(health);
|
||||
let (mut query, _) = listener.accept().await.unwrap();
|
||||
let request = read_request(&mut query).await;
|
||||
started.send(()).unwrap();
|
||||
let (mut kill, _) = tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
|
||||
let kill_request = read_request(&mut kill).await;
|
||||
reply(&mut kill, "200 OK", "", "").await;
|
||||
(request, kill_request)
|
||||
});
|
||||
let pool = Pool::connect(&source(port), None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
|
||||
let cancelled = async {
|
||||
received.await.unwrap();
|
||||
cancel.cancel();
|
||||
};
|
||||
let (result, ()) = tokio::join!(query, cancelled);
|
||||
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
|
||||
let (query, kill) = server.await.unwrap();
|
||||
let target = query.lines().next().unwrap().split_whitespace().nth(1).unwrap();
|
||||
let url = Url::parse(&format!("http://localhost{target}")).unwrap();
|
||||
let query_id = url.query_pairs().find(|(k, _)| k == "query_id").unwrap().1.into_owned();
|
||||
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
|
||||
assert!(!kill.contains("session_id="));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
@@ -303,9 +303,7 @@ async fn read_frame(output: &mut (impl AsyncRead + Unpin)) -> IdeResult<Vec<u8>>
|
||||
const CANCEL_GRACE: Duration = Duration::from_secs(3);
|
||||
|
||||
fn cancel_timeout() -> IdeError {
|
||||
IdeError::invalid(
|
||||
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect.",
|
||||
)
|
||||
IdeError::invalid("The JDBC driver did not stop in time. The session was closed. Reconnect to continue.")
|
||||
}
|
||||
|
||||
async fn exchange(
|
||||
@@ -604,13 +602,7 @@ impl DbManager {
|
||||
pub(crate) async fn jdbc_completion(&self, id: &str, pool: &JdbcPool) -> IdeResult<crate::CompletionModel> {
|
||||
let mut tables = vec![];
|
||||
let mut column_count = 0;
|
||||
// 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();
|
||||
let schemas = self.schemas(id).await?;
|
||||
for schema in &schemas {
|
||||
// Columns of the whole namespace in one call; a driver that refuses it still completes tables.
|
||||
let mut columns = if column_count < crate::MAX_META_ROWS {
|
||||
|
||||
@@ -124,45 +124,6 @@ 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`].
|
||||
@@ -804,24 +765,4 @@ mod tests {
|
||||
assert_eq!(r.snowflake().auth, DbSnowflakeAuth::Browser);
|
||||
assert_eq!(scheme_driver("snowflake"), Some(DbDriver::Snowflake));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn introspection_shows_only_the_picked_schemas() {
|
||||
let mut i = DbIntrospection::default();
|
||||
assert!(i.shows_schema("SYS"), "the default reads every schema");
|
||||
|
||||
i.all_schemas = false;
|
||||
assert!(!i.shows_schema("SYS"), "nothing picked: the tree lists nothing either");
|
||||
|
||||
i.schemas = vec!["XMCB".into(), " APP_* ".into()];
|
||||
assert!(i.shows_schema("XMCB"));
|
||||
assert!(i.shows_schema("APP_INFO"));
|
||||
assert!(!i.shows_schema("APP"), "`*` needs the text that follows it");
|
||||
assert!(!i.shows_schema("SYS"));
|
||||
assert!(!i.shows_schema("xmcb"), "patterns match the names the server returned");
|
||||
|
||||
i.schemas = vec!["?".into()];
|
||||
assert!(i.shows_schema("A"));
|
||||
assert!(!i.shows_schema("AB"));
|
||||
}
|
||||
}
|
||||
@@ -210,13 +210,9 @@ async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
|
||||
})
|
||||
.await
|
||||
.expect("driver cancellation must be bounded");
|
||||
assert_eq!(
|
||||
result.unwrap_err().message,
|
||||
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect."
|
||||
);
|
||||
assert!(db.connected().is_empty());
|
||||
assert_eq!(db.execute("test", "after cancellation", 1, &normal).await?.affected, Some(1.0));
|
||||
assert_eq!(db.connected(), ["test"]);
|
||||
assert!(result.unwrap_err().message.contains("Reconnect"));
|
||||
db.disconnect("test").await;
|
||||
assert_eq!(db.execute("test", "after reconnect", 1, &normal).await?.affected, Some(1.0));
|
||||
db.disconnect("test").await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1,54 +0,0 @@
|
||||
[package]
|
||||
name = "ide-drag-out"
|
||||
description = "OS file drags out of an app window, so file managers and transfer clients copy the files: GTK on Linux, OLE on Windows, AppKit on macOS"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[dependencies]
|
||||
|
||||
[target.'cfg(target_os = "linux")'.dependencies]
|
||||
gtk = "0.18"
|
||||
|
||||
[target.'cfg(any(windows, target_os = "macos"))'.dependencies]
|
||||
raw-window-handle = "0.6"
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows = { version = "0.62", features = [
|
||||
"Win32_Foundation",
|
||||
"Win32_Graphics_Gdi",
|
||||
"Win32_System_Com",
|
||||
"Win32_System_Com_StructuredStorage",
|
||||
"Win32_System_Memory",
|
||||
"Win32_System_Ole",
|
||||
"Win32_System_SystemServices",
|
||||
"Win32_UI_Shell",
|
||||
"Win32_UI_Shell_Common",
|
||||
] }
|
||||
# `#[implement]` expands to paths into `windows_core`.
|
||||
windows-core = "0.62"
|
||||
|
||||
[target.'cfg(target_os = "macos")'.dependencies]
|
||||
objc2 = { version = "0.6", default-features = false, features = ["std"] }
|
||||
objc2-foundation = { version = "0.3", default-features = false, features = ["std", "NSArray", "NSGeometry", "NSObject", "NSString", "NSURL"] }
|
||||
objc2-app-kit = { version = "0.3", default-features = false, features = [
|
||||
"std",
|
||||
"objc2-core-foundation",
|
||||
"NSApplication",
|
||||
"NSDragging",
|
||||
"NSDraggingItem",
|
||||
"NSDraggingSession",
|
||||
"NSEvent",
|
||||
"NSGraphics",
|
||||
"NSGraphicsContext",
|
||||
"NSImage",
|
||||
"NSPasteboard",
|
||||
"NSPasteboardItem",
|
||||
"NSResponder",
|
||||
"NSView",
|
||||
"NSWindow",
|
||||
"NSWorkspace",
|
||||
] }
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile.workspace = true
|
||||
@@ -1,122 +0,0 @@
|
||||
//! macOS: an AppKit dragging session with one pasteboard item per path, each a file URL.
|
||||
|
||||
use super::Outcome;
|
||||
use objc2::rc::Retained;
|
||||
use objc2::runtime::ProtocolObject;
|
||||
use objc2::{AnyThread, DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send};
|
||||
use objc2_app_kit::{
|
||||
NSApplication, NSDragOperation, NSDraggingContext, NSDraggingItem, NSDraggingSession, NSDraggingSource, NSEvent,
|
||||
NSEventModifierFlags, NSEventType, NSPasteboardItem, NSPasteboardTypeFileURL, NSView, NSWorkspace,
|
||||
};
|
||||
use objc2_foundation::{NSArray, NSObject, NSObjectProtocol, NSPoint, NSRect, NSSize, NSString, NSURL};
|
||||
use raw_window_handle::{HasWindowHandle, RawWindowHandle};
|
||||
use std::cell::Cell;
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// The size of each file's icon under the pointer, in points.
|
||||
const ICON_SIZE: f64 = 32.0;
|
||||
|
||||
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`, each shown with its
|
||||
/// Finder icon; `done` runs on the main thread when the drag ends.
|
||||
pub fn start<W: HasWindowHandle>(
|
||||
window: &W,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
let mtm = MainThreadMarker::new().ok_or_else(|| io::Error::other("a drag starts on the main thread"))?;
|
||||
let RawWindowHandle::AppKit(handle) =
|
||||
window.window_handle().map_err(|error| io::Error::other(error.to_string()))?.as_raw()
|
||||
else {
|
||||
return Err(io::Error::other("not an AppKit window"));
|
||||
};
|
||||
// SAFETY: the handle names this window's view, alive while `window` is borrowed.
|
||||
let view = unsafe { handle.ns_view.cast::<NSView>().as_ref() };
|
||||
let window = view.window().ok_or_else(|| io::Error::other("the view has no window"))?;
|
||||
let content = window.contentView().ok_or_else(|| io::Error::other("the window has no content view"))?;
|
||||
// In window coordinates, which are the content view's.
|
||||
let pointer = window.mouseLocationOutsideOfEventStream();
|
||||
let frame = NSRect::new(
|
||||
NSPoint::new(pointer.x - ICON_SIZE / 2.0, pointer.y - ICON_SIZE / 2.0),
|
||||
NSSize::new(ICON_SIZE, ICON_SIZE),
|
||||
);
|
||||
|
||||
let workspace = NSWorkspace::sharedWorkspace();
|
||||
let mut items = Vec::with_capacity(paths.len());
|
||||
for path in &paths {
|
||||
let path = NSString::from_str(&path.to_string_lossy());
|
||||
let url = NSURL::fileURLWithPath(&path)
|
||||
.absoluteString()
|
||||
.ok_or_else(|| io::Error::other(format!("not a file URL: {path}")))?;
|
||||
let item = NSPasteboardItem::new();
|
||||
if !item.setString_forType(&url, unsafe { NSPasteboardTypeFileURL }) {
|
||||
return Err(io::Error::other(format!("cannot put {path} on the pasteboard")));
|
||||
}
|
||||
let drag_item =
|
||||
NSDraggingItem::initWithPasteboardWriter(NSDraggingItem::alloc(), ProtocolObject::from_ref(&*item));
|
||||
let icon = workspace.iconForFile(&path);
|
||||
unsafe { drag_item.setDraggingFrame_contents(frame, Some(&icon)) };
|
||||
items.push(drag_item);
|
||||
}
|
||||
|
||||
// The session starts from a drag event at the pointer: the web view's own mouse events
|
||||
// went to WebKit, and the current event may be a later one.
|
||||
let timestamp = NSApplication::sharedApplication(mtm).currentEvent().map_or(0.0, |event| event.timestamp());
|
||||
let event = NSEvent::mouseEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_clickCount_pressure(
|
||||
NSEventType::LeftMouseDragged,
|
||||
pointer,
|
||||
NSEventModifierFlags::empty(),
|
||||
timestamp,
|
||||
window.windowNumber(),
|
||||
None,
|
||||
0,
|
||||
1,
|
||||
1.0,
|
||||
)
|
||||
.ok_or_else(|| io::Error::other("cannot make the drag event"))?;
|
||||
let source = DragSource::new(Box::new(done), mtm);
|
||||
content.beginDraggingSessionWithItems_event_source(
|
||||
&NSArray::from_retained_slice(&items),
|
||||
&event,
|
||||
ProtocolObject::from_ref(&*source),
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
type Done = Box<dyn FnOnce(Outcome)>;
|
||||
|
||||
struct Ivars {
|
||||
done: Cell<Option<Done>>,
|
||||
}
|
||||
|
||||
define_class!(
|
||||
#[unsafe(super(NSObject))]
|
||||
#[thread_kind = MainThreadOnly]
|
||||
#[name = "OpenIdeaDragOutSource"]
|
||||
#[ivars = Ivars]
|
||||
struct DragSource;
|
||||
|
||||
unsafe impl NSObjectProtocol for DragSource {}
|
||||
|
||||
unsafe impl NSDraggingSource for DragSource {
|
||||
#[unsafe(method(draggingSession:sourceOperationMaskForDraggingContext:))]
|
||||
fn operation_mask(&self, session: &NSDraggingSession, _context: NSDraggingContext) -> NSDragOperation {
|
||||
session.setAnimatesToStartingPositionsOnCancelOrFail(true);
|
||||
NSDragOperation::Copy
|
||||
}
|
||||
|
||||
#[unsafe(method(draggingSession:endedAtPoint:operation:))]
|
||||
fn ended(&self, _session: &NSDraggingSession, _point: NSPoint, operation: NSDragOperation) {
|
||||
if let Some(done) = self.ivars().done.take() {
|
||||
done(if operation == NSDragOperation::None { Outcome::Cancelled } else { Outcome::Dropped });
|
||||
}
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
impl DragSource {
|
||||
fn new(done: Done, mtm: MainThreadMarker) -> Retained<Self> {
|
||||
let this = Self::alloc(mtm).set_ivars(Ivars { done: Cell::new(Some(done)) });
|
||||
unsafe { msg_send![super(this), init] }
|
||||
}
|
||||
}
|
||||
@@ -1,190 +0,0 @@
|
||||
//! OS file drags out of an app window: the app the files are dropped on (Explorer,
|
||||
//! Finder, a file manager, an SFTP client such as Xftp) copies them, as when they are
|
||||
//! dragged from IDEA's Project view (#2867).
|
||||
//!
|
||||
//! Linux starts a GTK drag offering `text/uri-list`, Windows an OLE `DoDragDrop` of a
|
||||
//! `CF_HDROP` data object, macOS an AppKit dragging session of file URLs. A drag is
|
||||
//! always a copy, never a move, so no target can take project files away.
|
||||
//!
|
||||
//! [`start`] runs on the UI thread while the primary button is still held. It returns
|
||||
//! once the drag has begun (Linux, macOS) or ended (Windows); `done` gets the outcome
|
||||
//! when it ends, or is dropped without being called when the backend lost track of it.
|
||||
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// How a drag ended.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Outcome {
|
||||
/// A target accepted the drop.
|
||||
Dropped,
|
||||
/// Released where nothing accepted it, or cancelled with Escape.
|
||||
Cancelled,
|
||||
}
|
||||
|
||||
/// The paths a drag may carry: at least one, each an absolute path to a file or folder
|
||||
/// on this machine. A remote project's paths name files on its server and fail here.
|
||||
/// Windows also refuses paths of `MAX_PATH` or more: Explorer can't copy from them.
|
||||
/// Network shares (`\\server\share\…`) are local paths here and drag like any other.
|
||||
pub fn local_paths<S: Into<PathBuf>>(paths: impl IntoIterator<Item = S>) -> io::Result<Vec<PathBuf>> {
|
||||
let paths: Vec<PathBuf> = paths.into_iter().map(Into::into).collect();
|
||||
if paths.is_empty() {
|
||||
return Err(io::Error::new(io::ErrorKind::InvalidInput, "no files to drag"));
|
||||
}
|
||||
for path in &paths {
|
||||
if !path.is_absolute() || std::fs::symlink_metadata(path).is_err() {
|
||||
return Err(io::Error::new(io::ErrorKind::NotFound, format!("not a local file: {}", path.display())));
|
||||
}
|
||||
if cfg!(windows) && !fits_max_path(path) {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
format!("path too long to drag: {}", path.display()),
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(paths)
|
||||
}
|
||||
|
||||
/// Whether `path` is shorter than Windows' `MAX_PATH` (260 UTF-16 units with the NUL).
|
||||
fn fits_max_path(path: &std::path::Path) -> bool {
|
||||
path.as_os_str().to_string_lossy().encode_utf16().count() < 260
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
pub use gtk_impl::start;
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
mod gtk_impl {
|
||||
use super::Outcome;
|
||||
use gtk::glib::{self, SignalHandlerId};
|
||||
use gtk::prelude::*;
|
||||
use gtk::{TargetList, gdk};
|
||||
use std::cell::{Cell, RefCell};
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
use std::rc::Rc;
|
||||
|
||||
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`; `done` runs on
|
||||
/// the UI thread when the drag ends.
|
||||
pub fn start(
|
||||
window: >k::ApplicationWindow,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
// `file://` URIs with every reserved or non-ASCII byte escaped.
|
||||
let uris = paths
|
||||
.iter()
|
||||
.map(|path| glib::filename_to_uri(path, None).map(|uri| uri.to_string()))
|
||||
.collect::<Result<Vec<_>, _>>()
|
||||
.map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error.to_string()))?;
|
||||
let targets = TargetList::new(&[]);
|
||||
targets.add_uri_targets(0);
|
||||
// The button that started the drag (1), not its mask: GTK ends the drag on that
|
||||
// button's release.
|
||||
let context = window
|
||||
.drag_begin_with_coordinates(&targets, gdk::DragAction::COPY, 1, None, -1, -1)
|
||||
.ok_or_else(|| io::Error::other("the window system refused to start a drag"))?;
|
||||
|
||||
let outcome = Rc::new(Cell::new(Outcome::Cancelled));
|
||||
context.connect_drop_performed({
|
||||
let outcome = outcome.clone();
|
||||
move |_, _| outcome.set(Outcome::Dropped)
|
||||
});
|
||||
let handlers: Rc<RefCell<Vec<SignalHandlerId>>> = Rc::default();
|
||||
let data = window.connect_drag_data_get({
|
||||
let context = context.clone();
|
||||
move |_, ctx, selection, _, _| {
|
||||
if *ctx == context {
|
||||
let uris: Vec<&str> = uris.iter().map(String::as_str).collect();
|
||||
selection.set_uris(&uris);
|
||||
}
|
||||
}
|
||||
});
|
||||
// The target asks for the data after the drop (XDND is asynchronous), so the data
|
||||
// handler stays connected until `drag-end`, which GTK emits last.
|
||||
let done = Cell::new(Some(done));
|
||||
let end = window.connect_drag_end({
|
||||
let handlers = handlers.clone();
|
||||
move |window, ctx| {
|
||||
if *ctx != context {
|
||||
return;
|
||||
}
|
||||
for handler in handlers.borrow_mut().drain(..) {
|
||||
window.disconnect(handler);
|
||||
}
|
||||
if let Some(done) = done.take() {
|
||||
done(outcome.get());
|
||||
}
|
||||
}
|
||||
});
|
||||
handlers.borrow_mut().extend([data, end]);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
mod ole;
|
||||
#[cfg(windows)]
|
||||
pub use ole::start;
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
mod appkit;
|
||||
#[cfg(target_os = "macos")]
|
||||
pub use appkit::start;
|
||||
|
||||
/// The `CF_HDROP` file list: each path in UTF-16 with `/` as `\\`, NUL-terminated, and a
|
||||
/// second NUL after the last.
|
||||
#[cfg(any(windows, test))]
|
||||
fn hdrop_file_list<P: IntoIterator<Item = u16>>(paths: impl IntoIterator<Item = P>) -> Vec<u16> {
|
||||
let mut list = Vec::new();
|
||||
for path in paths {
|
||||
list.extend(path.into_iter().map(|unit| if unit == u16::from(b'/') { u16::from(b'\\') } else { unit }));
|
||||
list.push(0);
|
||||
}
|
||||
list.push(0);
|
||||
list
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn accepts_existing_absolute_files_and_folders() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let file = dir.path().join("a b ü.txt");
|
||||
std::fs::write(&file, "x").unwrap();
|
||||
let paths = local_paths([file.clone(), dir.path().to_path_buf()]).unwrap();
|
||||
assert_eq!(paths, vec![file, dir.path().to_path_buf()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn measures_max_path_in_utf16_units() {
|
||||
let path = |len: usize| PathBuf::from(format!("C:/{}", "中".repeat(len - 3)));
|
||||
assert!(fits_max_path(&path(259)));
|
||||
assert!(!fits_max_path(&path(260)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lists_hdrop_files_double_nul_terminated() {
|
||||
let list = hdrop_file_list(["C:/a b/ü.txt", r"\\nas\share\中"].map(str::encode_utf16));
|
||||
let expected: Vec<u16> = "C:\\a b\\ü.txt\0\\\\nas\\share\\中\0\0".encode_utf16().collect();
|
||||
assert_eq!(list, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_an_empty_drag() {
|
||||
assert_eq!(local_paths(Vec::<PathBuf>::new()).unwrap_err().kind(), io::ErrorKind::InvalidInput);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_relative_and_missing_paths() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let file = dir.path().join("a.txt");
|
||||
std::fs::write(&file, "x").unwrap();
|
||||
// One path that is not local fails the whole drag: none of it is half-copied.
|
||||
for bad in [PathBuf::from("a.txt"), dir.path().join("missing.txt")] {
|
||||
assert_eq!(local_paths([file.clone(), bad]).unwrap_err().kind(), io::ErrorKind::NotFound);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,171 +0,0 @@
|
||||
//! Windows: OLE `DoDragDrop` of a data object that serves the paths as `CF_HDROP`.
|
||||
|
||||
use super::{Outcome, hdrop_file_list};
|
||||
use raw_window_handle::HasWindowHandle;
|
||||
use std::io;
|
||||
use std::os::windows::ffi::OsStrExt;
|
||||
use std::path::PathBuf;
|
||||
use windows::Win32::Foundation::{
|
||||
DRAGDROP_S_CANCEL, DRAGDROP_S_DROP, DRAGDROP_S_USEDEFAULTCURSORS, DV_E_FORMATETC, E_NOTIMPL, GlobalFree, HGLOBAL,
|
||||
OLE_E_ADVISENOTSUPPORTED, S_OK,
|
||||
};
|
||||
use windows::Win32::System::Com::{
|
||||
DATADIR_GET, DVASPECT_CONTENT, FORMATETC, IAdviseSink, IDataObject, IDataObject_Impl, IEnumFORMATETC,
|
||||
IEnumSTATDATA, STGMEDIUM, STGMEDIUM_0, TYMED_HGLOBAL,
|
||||
};
|
||||
use windows::Win32::System::Memory::{GHND, GlobalAlloc, GlobalLock, GlobalUnlock};
|
||||
use windows::Win32::System::Ole::{
|
||||
CF_HDROP, DROPEFFECT, DROPEFFECT_COPY, DROPEFFECT_NONE, DoDragDrop, IDropSource, IDropSource_Impl, OleInitialize,
|
||||
OleUninitialize,
|
||||
};
|
||||
use windows::Win32::System::SystemServices::{MK_LBUTTON, MODIFIERKEYS_FLAGS};
|
||||
use windows::Win32::UI::Shell::{DROPFILES, SHCreateDataObject, SHCreateStdEnumFmtEtc};
|
||||
use windows::core::{BOOL, Error, HRESULT, Ref, Result, implement};
|
||||
|
||||
/// Drags `paths` (see [`super::local_paths`]) until the button is released, then calls
|
||||
/// `done` and returns. `DoDragDrop` runs its own message loop, so the window keeps painting.
|
||||
pub fn start<W: HasWindowHandle>(
|
||||
_window: &W,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
let files = hdrop_file_list(paths.iter().map(|path| path.as_os_str().encode_wide()));
|
||||
// The window's event loop has initialised OLE on this thread already; this takes a
|
||||
// reference that `OleUninitialize` gives back.
|
||||
unsafe { OleInitialize(None) }.map_err(io::Error::other)?;
|
||||
let outcome = drag(files);
|
||||
unsafe { OleUninitialize() };
|
||||
done(outcome.map_err(io::Error::other)?);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn drag(files: Vec<u16>) -> Result<Outcome> {
|
||||
// Formats other than `CF_HDROP` (the drag image, drop descriptions the shell sets on
|
||||
// the source's data object) are kept by a plain shell data object.
|
||||
let inner: IDataObject = unsafe { SHCreateDataObject(None, None, None::<&IDataObject>) }?;
|
||||
let data: IDataObject = DataObject { files, inner }.into();
|
||||
let source: IDropSource = DropSource.into();
|
||||
let mut effect = DROPEFFECT_NONE;
|
||||
match unsafe { DoDragDrop(&data, &source, DROPEFFECT_COPY, &mut effect) } {
|
||||
DRAGDROP_S_DROP if effect != DROPEFFECT_NONE => Ok(Outcome::Dropped),
|
||||
DRAGDROP_S_DROP | DRAGDROP_S_CANCEL => Ok(Outcome::Cancelled),
|
||||
error => Err(Error::from_hresult(error)),
|
||||
}
|
||||
}
|
||||
|
||||
#[implement(IDropSource)]
|
||||
struct DropSource;
|
||||
|
||||
impl IDropSource_Impl for DropSource_Impl {
|
||||
fn QueryContinueDrag(&self, escape_pressed: BOOL, keys: MODIFIERKEYS_FLAGS) -> HRESULT {
|
||||
if escape_pressed.as_bool() {
|
||||
DRAGDROP_S_CANCEL
|
||||
} else if keys & MK_LBUTTON == MODIFIERKEYS_FLAGS(0) {
|
||||
DRAGDROP_S_DROP
|
||||
} else {
|
||||
S_OK
|
||||
}
|
||||
}
|
||||
|
||||
fn GiveFeedback(&self, _effect: DROPEFFECT) -> HRESULT {
|
||||
DRAGDROP_S_USEDEFAULTCURSORS
|
||||
}
|
||||
}
|
||||
|
||||
#[implement(IDataObject)]
|
||||
struct DataObject {
|
||||
/// The `DROPFILES` file list ([`hdrop_file_list`]).
|
||||
files: Vec<u16>,
|
||||
inner: IDataObject,
|
||||
}
|
||||
|
||||
const HDROP: FORMATETC = FORMATETC {
|
||||
cfFormat: CF_HDROP.0,
|
||||
ptd: std::ptr::null_mut(),
|
||||
dwAspect: DVASPECT_CONTENT.0,
|
||||
lindex: -1,
|
||||
tymed: TYMED_HGLOBAL.0 as u32,
|
||||
};
|
||||
|
||||
fn is_hdrop(format: *const FORMATETC) -> bool {
|
||||
unsafe { format.as_ref() }.is_some_and(|format| {
|
||||
format.cfFormat == HDROP.cfFormat && format.dwAspect == HDROP.dwAspect && format.tymed & HDROP.tymed != 0
|
||||
})
|
||||
}
|
||||
|
||||
impl DataObject {
|
||||
/// A new `DROPFILES` block; the receiver frees it.
|
||||
fn hdrop(&self) -> Result<HGLOBAL> {
|
||||
let header = size_of::<DROPFILES>();
|
||||
let size = header + std::mem::size_of_val(self.files.as_slice());
|
||||
unsafe {
|
||||
let handle = GlobalAlloc(GHND, size)?;
|
||||
let block = GlobalLock(handle).cast::<u8>();
|
||||
if block.is_null() {
|
||||
let error = Error::from_thread();
|
||||
let _ = GlobalFree(Some(handle));
|
||||
return Err(error);
|
||||
}
|
||||
block.cast::<DROPFILES>().write_unaligned(DROPFILES {
|
||||
pFiles: header as u32,
|
||||
fWide: true.into(),
|
||||
..Default::default()
|
||||
});
|
||||
std::ptr::copy_nonoverlapping(self.files.as_ptr().cast::<u8>(), block.add(header), size - header);
|
||||
// Fails with no error once the lock count is back to zero, which it is.
|
||||
let _ = GlobalUnlock(handle);
|
||||
Ok(handle)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl IDataObject_Impl for DataObject_Impl {
|
||||
fn GetData(&self, format: *const FORMATETC) -> Result<STGMEDIUM> {
|
||||
if !is_hdrop(format) {
|
||||
return unsafe { self.inner.GetData(format) };
|
||||
}
|
||||
Ok(STGMEDIUM {
|
||||
tymed: TYMED_HGLOBAL.0 as u32,
|
||||
u: STGMEDIUM_0 { hGlobal: self.hdrop()? },
|
||||
pUnkForRelease: std::mem::ManuallyDrop::new(None),
|
||||
})
|
||||
}
|
||||
|
||||
fn GetDataHere(&self, format: *const FORMATETC, medium: *mut STGMEDIUM) -> Result<()> {
|
||||
if is_hdrop(format) {
|
||||
return Err(DV_E_FORMATETC.into());
|
||||
}
|
||||
unsafe { self.inner.GetDataHere(format, medium) }
|
||||
}
|
||||
|
||||
fn QueryGetData(&self, format: *const FORMATETC) -> HRESULT {
|
||||
if is_hdrop(format) { S_OK } else { unsafe { self.inner.QueryGetData(format) } }
|
||||
}
|
||||
|
||||
fn GetCanonicalFormatEtc(&self, format: *const FORMATETC, canonical: *mut FORMATETC) -> HRESULT {
|
||||
unsafe { self.inner.GetCanonicalFormatEtc(format, canonical) }
|
||||
}
|
||||
|
||||
fn SetData(&self, format: *const FORMATETC, medium: *const STGMEDIUM, release: BOOL) -> Result<()> {
|
||||
unsafe { self.inner.SetData(format, medium, release.as_bool()) }
|
||||
}
|
||||
|
||||
fn EnumFormatEtc(&self, direction: u32) -> Result<IEnumFORMATETC> {
|
||||
if direction != DATADIR_GET.0 as u32 {
|
||||
return Err(E_NOTIMPL.into());
|
||||
}
|
||||
unsafe { SHCreateStdEnumFmtEtc(&[HDROP]) }
|
||||
}
|
||||
|
||||
fn DAdvise(&self, _format: *const FORMATETC, _advf: u32, _sink: Ref<IAdviseSink>) -> Result<u32> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
|
||||
fn DUnadvise(&self, _connection: u32) -> Result<()> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
|
||||
fn EnumDAdvise(&self) -> Result<IEnumSTATDATA> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
}
|
||||
@@ -5,10 +5,10 @@ use crate::Host;
|
||||
use crate::agent_secrets::{AgentSecrets, Kept};
|
||||
use ide_agent::registry::{AgentRegistry, RegistryPaths};
|
||||
use ide_agent::{
|
||||
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCliOffer,
|
||||
AgentCliUpdateResult, AgentCommand, AgentContextUsage, AgentEntry, AgentEvent, AgentModelCatalog, AgentProbe,
|
||||
AgentPrompt, AgentProvider, AgentQueued, AgentTask, CustomAgentInput, ExternalSession, McpExternalSource,
|
||||
McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput, McpTransport, NewAgentTask,
|
||||
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, 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,28 +17,12 @@ use ide_tools::InstallEvent;
|
||||
use std::collections::HashSet;
|
||||
use std::sync::{LazyLock, Mutex};
|
||||
|
||||
/// 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.
|
||||
/// Streams the project's agent events to this window; returns every task.
|
||||
#[command(trust = always)]
|
||||
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(())
|
||||
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);
|
||||
})))
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
@@ -359,50 +343,6 @@ 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)]
|
||||
@@ -1146,8 +1086,6 @@ ide_command::domain!(
|
||||
agent_cancel,
|
||||
agent_context_usage,
|
||||
agent_changes,
|
||||
agent_cli_update,
|
||||
agent_cli_update_check,
|
||||
agent_commands,
|
||||
agent_create,
|
||||
agent_delete,
|
||||
@@ -1187,5 +1125,4 @@ ide_command::domain!(
|
||||
agent_subscribe,
|
||||
agent_unarchive,
|
||||
agent_unqueue,
|
||||
agent_unsubscribe,
|
||||
);
|
||||
@@ -1,7 +1,6 @@
|
||||
//! Cucumber sources: the project's `.feature` files and the JavaScript / TypeScript files
|
||||
//! (`@cucumber/cucumber`, `playwright-bdd`) and Java / Kotlin files (cucumber-jvm's
|
||||
//! `@Given("…")` annotations and Java 8 lambdas) and Python files (behave and pytest-bdd's
|
||||
//! `@given('…')` decorators) that could define steps, with their text. The UI
|
||||
//! `@Given("…")` annotations and Java 8 lambdas) that could define steps, with their text. The UI
|
||||
//! owns the Gherkin and step-expression parsing and the index it feeds (as for `routes`),
|
||||
//! so this side stays a cheap scan.
|
||||
|
||||
@@ -22,8 +21,6 @@ const MAX_FILE_BYTES: u64 = 2 << 20;
|
||||
|
||||
/// What a step definition call starts with (`Given('…'`, `defineStep(/…/`).
|
||||
const STEP_CALLS: [&str; 5] = ["Given(", "When(", "Then(", "Step(", "defineStep("];
|
||||
/** What a Python step decorator starts with (behave also takes the capitalized names). */
|
||||
const PYTHON_STEP_CALLS: [&str; 8] = ["@given(", "@when(", "@then(", "@step(", "@Given(", "@When(", "@Then(", "@Step("];
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -41,14 +38,10 @@ fn is_feature(path: &Path) -> bool {
|
||||
fn is_script(path: &Path) -> bool {
|
||||
matches!(
|
||||
path.extension().and_then(|e| e.to_str()),
|
||||
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt" | "py")
|
||||
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt")
|
||||
)
|
||||
}
|
||||
|
||||
fn is_python(path: &Path) -> bool {
|
||||
path.extension().and_then(|e| e.to_str()) == Some("py")
|
||||
}
|
||||
|
||||
/// The feature files and step definition files under `root`.
|
||||
pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
|
||||
let found: Mutex<Vec<StepSource>> = Mutex::new(Vec::new());
|
||||
@@ -62,8 +55,7 @@ pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
|
||||
return;
|
||||
}
|
||||
let Ok(text) = std::fs::read_to_string(path) else { return };
|
||||
let calls: &[&str] = if is_python(path) { &PYTHON_STEP_CALLS } else { &STEP_CALLS };
|
||||
if !feature && !calls.iter().any(|call| text.contains(call)) {
|
||||
if !feature && !STEP_CALLS.iter().any(|call| text.contains(call)) {
|
||||
return;
|
||||
}
|
||||
let Ok(mut found) = found.lock() else { return };
|
||||
@@ -84,7 +76,6 @@ pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult<Vec<StepSource>>
|
||||
let mut excludes = project.search_excludes();
|
||||
// Cucumber's own sources (and every other package's) are not the project's steps.
|
||||
excludes.push("node_modules".to_owned());
|
||||
excludes.push("site-packages".to_owned());
|
||||
let mut out = Vec::new();
|
||||
for root in std::iter::once(project.root.clone()).chain(project.content_roots()) {
|
||||
out.extend(sources_in(&root, &excludes));
|
||||
@@ -113,23 +104,11 @@ mod tests {
|
||||
std::fs::write(root.join("src/CartSteps.java"), "@Given(\"an empty cart\")\npublic void empty() {}").unwrap();
|
||||
std::fs::write(root.join("src/App.java"), "class App {}").unwrap();
|
||||
std::fs::write(root.join("src/notes.md"), "Given('x')").unwrap();
|
||||
std::fs::write(root.join("steps/cart_steps.py"), "@given('an empty cart')\ndef step_impl(context): pass")
|
||||
.unwrap();
|
||||
std::fs::write(root.join("src/util.py"), "def given(x): return x\nWhen = given('x')").unwrap();
|
||||
std::fs::write(root.join("node_modules/@cucumber/cucumber/lib/index.js"), "Given('x')").unwrap();
|
||||
let files = sources_in(root, &["node_modules".to_owned()]);
|
||||
let names: Vec<String> =
|
||||
files.iter().map(|f| f.path.0.strip_prefix(root).unwrap().to_string_lossy().replace('\\', "/")).collect();
|
||||
assert_eq!(
|
||||
names,
|
||||
[
|
||||
"features/cart.feature",
|
||||
"src/CartSteps.java",
|
||||
"steps/bdd.mjs",
|
||||
"steps/cart.steps.ts",
|
||||
"steps/cart_steps.py"
|
||||
]
|
||||
);
|
||||
assert_eq!(names, ["features/cart.feature", "src/CartSteps.java", "steps/bdd.mjs", "steps/cart.steps.ts"]);
|
||||
assert!(files[0].feature && !files[1].feature);
|
||||
assert!(files[3].text.contains("an empty cart"));
|
||||
}
|
||||
|
||||
@@ -342,11 +342,6 @@ pub async fn debug_variables(host: &Host, session: DebugSessionId, reference: i6
|
||||
host.debugger.variables(session, reference).await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_resolve_variable(host: &Host, session: DebugSessionId, variable: Variable) -> IdeResult<Variable> {
|
||||
host.debugger.resolve_variable(session, variable).await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn debug_evaluate(
|
||||
host: &Host,
|
||||
@@ -839,7 +834,6 @@ ide_command::domain!(
|
||||
debug_listen_for_jvm,
|
||||
debug_pause,
|
||||
debug_redefine_classes,
|
||||
debug_resolve_variable,
|
||||
debug_restart_frame,
|
||||
debug_resume,
|
||||
debug_run_to,
|
||||
|
||||
@@ -633,14 +633,8 @@ 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 {
|
||||
let in_project = path != &project.root && path.starts_with(&project.root);
|
||||
if !in_project && repos.for_path(path).is_none() {
|
||||
if path == &project.root || !path.starts_with(&project.root) {
|
||||
return Err(ide_core::IdeError::invalid("Ignore selection is outside the project"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -21,7 +21,6 @@ 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"]);
|
||||
@@ -66,75 +65,3 @@ async fn patches_read_and_write_the_requested_repository() {
|
||||
assert!(vcs::vcs_apply_patch(&host, "main", Some(base.join("outside")), String::new()).await.is_err());
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
/// The Changes view also lists attached projects' repositories, and their untracked files
|
||||
/// offer Add to .gitignore / .git/info/exclude: the guard must follow the window's
|
||||
/// repository set, not the project folder alone.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn add_to_ignore_accepts_the_repositories_of_attached_projects() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let project_root = base.join("project");
|
||||
let attached_root = base.join("attached");
|
||||
for root in [&project_root, &attached_root] {
|
||||
std::fs::create_dir_all(root).unwrap();
|
||||
git(root, &["init", "-b", "main"]);
|
||||
git(root, &["config", "user.name", "Test"]);
|
||||
git(root, &["config", "user.email", "[email protected]"]);
|
||||
git(root, &["config", "core.autocrlf", "false"]);
|
||||
std::fs::write(root.join("tracked.txt"), "x\n").unwrap();
|
||||
git(root, &["add", "."]);
|
||||
git(root, &["commit", "-m", "initial"]);
|
||||
}
|
||||
// Untracked files, one per repository; the attached one is what failed.
|
||||
let own = project_root.join("own.ignore-me");
|
||||
let attached = attached_root.join("attached.ignore-me");
|
||||
std::fs::write(&own, "x").unwrap();
|
||||
std::fs::write(&attached, "x").unwrap();
|
||||
|
||||
let host = Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("data"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(|_| Arc::new(NullSink)),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
});
|
||||
host.trust.decide(&project_root, true, false).unwrap();
|
||||
host.trust.decide(&attached_root, true, false).unwrap();
|
||||
let project = host.open_project("main", &project_root).unwrap();
|
||||
ide_host::ops::project::attach_workspace(&host, "main", &attached_root).unwrap();
|
||||
for _ in 0..500 {
|
||||
if project.repos().all().len() == 2 {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
assert_eq!(project.repos().all().len(), 2);
|
||||
|
||||
vcs::vcs_add_to_ignore(&host, "main", vec![attached.clone()], ide_vcs::IgnoreDestination::Gitignore).await.unwrap();
|
||||
assert!(
|
||||
std::fs::read_to_string(attached_root.join(".gitignore")).unwrap().contains("/attached.ignore-me"),
|
||||
"the attached repository's .gitignore did not receive the rule"
|
||||
);
|
||||
vcs::vcs_add_to_ignore(&host, "main", vec![own.clone()], ide_vcs::IgnoreDestination::LocalExclude).await.unwrap();
|
||||
assert!(
|
||||
std::fs::read_to_string(project_root.join(".git/info/exclude")).unwrap().contains("/own.ignore-me"),
|
||||
"the project repository's exclude did not receive the rule"
|
||||
);
|
||||
|
||||
// A repository of an unattached sibling folder stays outside.
|
||||
let sibling_root = base.join("sibling");
|
||||
std::fs::create_dir_all(&sibling_root).unwrap();
|
||||
git(&sibling_root, &["init", "-b", "main"]);
|
||||
let sibling = sibling_root.join("sibling.ignore-me");
|
||||
std::fs::write(&sibling, "x").unwrap();
|
||||
let error =
|
||||
vcs::vcs_add_to_ignore(&host, "main", vec![sibling], ide_vcs::IgnoreDestination::Gitignore).await.unwrap_err();
|
||||
assert!(error.message.contains("outside the project"), "{error:?}");
|
||||
assert!(!sibling_root.join(".gitignore").exists());
|
||||
host.close_project("main");
|
||||
}
|
||||
@@ -15,8 +15,6 @@ 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, Instant};
|
||||
use std::time::Duration;
|
||||
|
||||
/// `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,61 +62,33 @@ 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<Cached>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, build, system_proxy)
|
||||
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, build)
|
||||
}
|
||||
|
||||
/// 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<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
|
||||
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, |proxy| build_with_redirect(proxy, reqwest::redirect::Policy::none()))
|
||||
}
|
||||
|
||||
fn cached_client(
|
||||
slot: &Mutex<Option<Cached>>,
|
||||
build: impl Fn(&ProxySettings) -> IdeResult<reqwest::Client>,
|
||||
system: fn() -> String,
|
||||
slot: &Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>>,
|
||||
build: fn(&ProxySettings) -> IdeResult<reqwest::Client>,
|
||||
) -> 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(c) = cached.as_ref()
|
||||
&& *c.settings == *proxy
|
||||
&& c.system == system
|
||||
if let Some((settings, client)) = cached.as_ref()
|
||||
&& **settings == *proxy
|
||||
{
|
||||
return Ok(c.client.clone());
|
||||
return Ok(client.clone());
|
||||
}
|
||||
let client = build(&proxy)?;
|
||||
*cached = Some(Cached { settings: proxy, system, client: client.clone() });
|
||||
*cached = Some((proxy, client.clone()));
|
||||
Ok(client)
|
||||
}
|
||||
|
||||
@@ -170,36 +142,6 @@ pub fn describe(e: &reqwest::Error) -> String {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn auto_mode_rebuilds_the_shared_client_when_the_system_proxy_changes() {
|
||||
static SYSTEM: Mutex<String> = Mutex::new(String::new());
|
||||
static BUILDS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||||
fn system() -> String {
|
||||
SYSTEM.lock().clone()
|
||||
}
|
||||
let slot = Mutex::new(None);
|
||||
let get = || {
|
||||
cached_client(
|
||||
&slot,
|
||||
|proxy| {
|
||||
BUILDS.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
||||
build(proxy)
|
||||
},
|
||||
system,
|
||||
)
|
||||
.unwrap()
|
||||
};
|
||||
assert_eq!(ide_core::proxy_settings::proxy().mode, ProxyMode::Auto);
|
||||
get();
|
||||
get();
|
||||
assert_eq!(BUILDS.load(std::sync::atomic::Ordering::SeqCst), 1);
|
||||
// A proxy app switches the system proxy on after launch.
|
||||
*SYSTEM.lock() = "Matcher { https: 127.0.0.1:7890 }".into();
|
||||
get();
|
||||
get();
|
||||
assert_eq!(BUILDS.load(std::sync::atomic::Ordering::SeqCst), 2);
|
||||
}
|
||||
use ide_core::proxy_settings::ProxyKind;
|
||||
use std::io::{BufRead, BufReader, Write};
|
||||
use std::net::TcpListener;
|
||||
|
||||
@@ -13,9 +13,6 @@ 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: ...`).
|
||||
@@ -392,7 +389,7 @@ impl Store {
|
||||
|
||||
fn open_db(&self) -> Result<Database> {
|
||||
let file = self.snapshot.with_file_name("index.redb");
|
||||
let db = match Database::builder().set_cache_size(DB_CACHE_BYTES).create(&file) {
|
||||
let db = match Database::create(&file) {
|
||||
Ok(db) => db,
|
||||
Err(redb::DatabaseError::DatabaseAlreadyOpen) => {
|
||||
return Err(format!("{} is in use", file.display()));
|
||||
@@ -401,7 +398,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::builder().set_cache_size(DB_CACHE_BYTES).create(&file).map_err(err)?
|
||||
Database::create(&file).map_err(err)?
|
||||
}
|
||||
};
|
||||
let valid = {
|
||||
|
||||
@@ -472,8 +472,6 @@ 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> {
|
||||
|
||||
@@ -245,11 +245,6 @@ pub struct DebuggerConfig {
|
||||
pub connect: Option<String>,
|
||||
#[serde(default)]
|
||||
pub install_hint: Option<String>,
|
||||
/// The adapter's lazy values (DAP `presentationHint.lazy`) are renderings such as `toString()`,
|
||||
/// safe to compute for every value shown: they are resolved before the UI sees them, as IDEA
|
||||
/// shows `toString()` at once. Off (getters with side effects), a value resolves when opened.
|
||||
#[serde(default)]
|
||||
pub resolve_lazy_variables: bool,
|
||||
/// Set on plugin languages: start exactly this approved program.
|
||||
#[serde(skip)]
|
||||
pub pinned: Option<ProgramPin>,
|
||||
|
||||
@@ -25,17 +25,6 @@ const PROGRESS_SWEEP: Duration = Duration::from_secs(15);
|
||||
/// visible, but stops holding the server busy while the work behind it keeps running.
|
||||
const PROGRESS_STALE: Duration = Duration::from_secs(180);
|
||||
|
||||
/// How long a cancelled progress task waits for its server to end it.
|
||||
const CANCEL_GRACE: Duration = Duration::from_secs(5);
|
||||
|
||||
/// The key of progress token `token` in [`Server::progress`].
|
||||
fn progress_key(token: &Value) -> String {
|
||||
match token {
|
||||
Value::String(s) => s.clone(),
|
||||
other => other.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Task message after [`PROGRESS_STALE`] of silence: keep the server's last message and
|
||||
/// say how long nothing happened.
|
||||
fn stalled_message(message: Option<&str>) -> String {
|
||||
@@ -108,50 +97,22 @@ impl ClientHandler {
|
||||
}
|
||||
|
||||
/// Cancelling task `task` asks this server instance to stop the work of progress `token`.
|
||||
/// A server that never ends it (Pyright waiting on a workspace that never loads) would
|
||||
/// leave the task "Cancelling…" for good: after [`CANCEL_GRACE`] the task ends here.
|
||||
fn cancel_handle(&self, task: TaskId, token: &Value) -> ide_core::task::CancelHandle {
|
||||
let (mgr, server, generation, token) = (self.mgr.clone(), self.server.clone(), self.generation, token.clone());
|
||||
let (server, generation, token) = (self.server.clone(), self.generation, token.clone());
|
||||
ide_core::task::on_cancel(task, move || {
|
||||
if let Some(run) = server.initialized_gen(generation)
|
||||
&& let Err(e) = run.peer.notify("window/workDoneProgress/cancel", json!({ "token": token }))
|
||||
{
|
||||
tracing::debug!("{}: cannot cancel progress: {e}", server.name);
|
||||
}
|
||||
let Some(runtime) = mgr.upgrade().map(|m| m.runtime.clone()) else { return };
|
||||
runtime.spawn(async move {
|
||||
tokio::time::sleep(CANCEL_GRACE).await;
|
||||
let Some(mgr) = mgr.upgrade() else { return };
|
||||
let key = progress_key(&token);
|
||||
let ended = {
|
||||
let mut progress = server.progress.lock();
|
||||
if progress.get(&key).is_none_or(|p| p.task != task) {
|
||||
return; // the server ended it, or the token began new work
|
||||
}
|
||||
progress.remove(&key)
|
||||
};
|
||||
if let Some(p) = ended {
|
||||
tracing::info!("{}: progress '{key}' did not end after cancel; ending its task", server.name);
|
||||
server.emit(
|
||||
mgr.sink(),
|
||||
IdeEvent::Task {
|
||||
id: p.task,
|
||||
title: p.title,
|
||||
message: p.message,
|
||||
fraction: None,
|
||||
done: true,
|
||||
cancellable: false,
|
||||
},
|
||||
);
|
||||
server.refresh_busy_status(mgr.sink());
|
||||
server.progress_ended();
|
||||
}
|
||||
});
|
||||
})
|
||||
}
|
||||
|
||||
fn progress(&self, mgr: &LspManager, params: Value) {
|
||||
let token = progress_key(¶ms["token"]);
|
||||
let token = match ¶ms["token"] {
|
||||
Value::String(s) => s.clone(),
|
||||
other => other.to_string(),
|
||||
};
|
||||
let value = ¶ms["value"];
|
||||
let kind = value.get("kind").and_then(Value::as_str);
|
||||
let message = value.get("message").and_then(Value::as_str).map(str::to_owned);
|
||||
|
||||
@@ -1049,14 +1049,12 @@ impl LspManager {
|
||||
if let Err(e) = peer.notify("initialized", json!({})) {
|
||||
tracing::warn!("{}: {e}", server.name);
|
||||
}
|
||||
// Sent even without settings: servers that don't ask with `workspace/configuration`
|
||||
// only learn settings this way, and Pyright, given workspace folders, waits for it
|
||||
// before asking and loading the workspace.
|
||||
let mut settings = handler::all_settings(&server.effective_config());
|
||||
if settings.is_null() {
|
||||
settings = json!({});
|
||||
}
|
||||
if let Err(e) = peer.notify("workspace/didChangeConfiguration", json!({ "settings": settings })) {
|
||||
// Servers that don't ask with `workspace/configuration` only learn settings this way.
|
||||
let cfg = server.effective_config();
|
||||
if cfg.settings.is_some()
|
||||
&& let Err(e) =
|
||||
peer.notify("workspace/didChangeConfiguration", json!({ "settings": handler::all_settings(&cfg) }))
|
||||
{
|
||||
tracing::debug!("{}: didChangeConfiguration: {e}", server.name);
|
||||
}
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
use ide_core::event::{LspRefreshKind, ServerStatus};
|
||||
use ide_core::{
|
||||
CancellationToken, DocId, FileEdit, IdeEvent, LanguageId, Pos, Range, ServerId, Severity, TaskId, WorkspaceEdit,
|
||||
CancellationToken, DocId, FileEdit, IdeEvent, LanguageId, Pos, Range, ServerId, Severity, WorkspaceEdit,
|
||||
};
|
||||
use ide_jsonrpc::{Handler, NoopHandler, Peer};
|
||||
use ide_language::{LanguageConfig, LanguageRegistry, LanguageServerConfig};
|
||||
@@ -1324,36 +1324,6 @@ async fn initialize_and_incremental_sync() {
|
||||
assert_eq!(infos[0].status, ServerStatus::Ready);
|
||||
}
|
||||
|
||||
/// Pyright, told the client has workspace folders, asks for its configuration and loads the
|
||||
/// workspace only after a `workspace/didChangeConfiguration`: every server gets one at startup.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn every_server_hears_its_configuration_once_initialized() {
|
||||
let cases = [
|
||||
(None, None, json!({})),
|
||||
(Some(json!({ "flag": true })), None, json!({ "flag": true })),
|
||||
(
|
||||
None,
|
||||
Some(json!({ "python": { "pythonPath": "/venv/bin/python" } })),
|
||||
json!({ "python": { "pythonPath": "/venv/bin/python" } }),
|
||||
),
|
||||
(Some(json!({ "flag": true })), Some(json!({ "other": 2 })), json!({ "flag": true, "other": 2 })),
|
||||
];
|
||||
for (init, settings, expected) in cases {
|
||||
let h = harness_configured("mock", "mk", &[("pyright", incremental_caps())], |cfg| {
|
||||
cfg.initialization_options = init.clone().map(|v| toml::Value::try_from(v).unwrap());
|
||||
cfg.settings = settings.clone();
|
||||
});
|
||||
h.open("a.mk", "x");
|
||||
h.wait_status("pyright", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("pyright");
|
||||
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
|
||||
assert_eq!(s.notified("workspace/didChangeConfiguration"), vec![json!({ "settings": expected })]);
|
||||
let order: Vec<String> = s.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
|
||||
let at = |m: &str| order.iter().position(|n| n == m).unwrap();
|
||||
assert!(at("initialized") < at("workspace/didChangeConfiguration"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn full_sync_and_desync_recovery() {
|
||||
let h = harness(&[("full", json!({ "textDocumentSync": 1 })), ("inc", json!({ "textDocumentSync": 2 }))]);
|
||||
@@ -2182,51 +2152,6 @@ async fn replacing_progress_keeps_cancellation_reports_and_indexing_on_the_new_t
|
||||
);
|
||||
}
|
||||
|
||||
/// A server that ignores `window/workDoneProgress/cancel` (Pyright waiting on a workspace
|
||||
/// that never loads) does not keep the task "Cancelling…": it ends after a grace period,
|
||||
/// once, and later reports on the token change nothing. A server that ends it in time ends it.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_cancelled_progress_the_server_never_ends_ends_on_its_own() {
|
||||
let h = harness(&[("mock", incremental_caps())]);
|
||||
h.open("a.mk", "x");
|
||||
h.wait_status("mock", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("mock");
|
||||
let peer = s.peer();
|
||||
let begin = |token: &str, title: &str| json!({ "token": token, "value": { "kind": "begin", "title": title, "cancellable": true } });
|
||||
let task_of = |title: &str| {
|
||||
h.events.lock().iter().find_map(|e| match e {
|
||||
IdeEvent::Task { id, title: t, done: false, .. } if t == title => Some(*id),
|
||||
_ => None,
|
||||
})
|
||||
};
|
||||
let ends = |task: TaskId| {
|
||||
h.events.lock().iter().filter(|e| matches!(e, IdeEvent::Task { id, done: true, .. } if *id == task)).count()
|
||||
};
|
||||
peer.notify("$/progress", begin("ignored", "Finding references")).unwrap();
|
||||
peer.notify("$/progress", begin("honoured", "Indexing")).unwrap();
|
||||
eventually(|| task_of("Finding references").is_some() && task_of("Indexing").is_some()).await;
|
||||
h.wait_status("mock", ServerStatus::Busy).await;
|
||||
let (ignored, honoured) = (task_of("Finding references").unwrap(), task_of("Indexing").unwrap());
|
||||
|
||||
assert!(ide_core::task::cancel(ignored));
|
||||
assert!(ide_core::task::cancel(honoured));
|
||||
eventually(|| s.notified("window/workDoneProgress/cancel").len() == 2).await;
|
||||
peer.notify("$/progress", json!({ "token": "honoured", "value": { "kind": "end" } })).unwrap();
|
||||
eventually(|| ends(honoured) == 1).await;
|
||||
assert_eq!(ends(ignored), 0, "the server still has its grace period");
|
||||
|
||||
eventually(|| ends(ignored) == 1).await;
|
||||
h.wait_status("mock", ServerStatus::Ready).await;
|
||||
// Late reports on the token reach no task.
|
||||
peer.notify("$/progress", json!({ "token": "ignored", "value": { "kind": "report", "message": "late" } })).unwrap();
|
||||
peer.notify("$/progress", json!({ "token": "ignored", "value": { "kind": "end" } })).unwrap();
|
||||
peer.notify("$/progress", begin("after", "After")).unwrap();
|
||||
eventually(|| task_of("After").is_some()).await;
|
||||
assert_eq!(ends(ignored), 1);
|
||||
assert_eq!(ends(honoured), 1);
|
||||
assert!(!h.events.lock().iter().any(|e| matches!(e, IdeEvent::Task { message: Some(m), .. } if m == "late")));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn cancelling_a_cancellable_progress_task_asks_the_server_to_stop() {
|
||||
let h = harness(&[("mock", incremental_caps())]);
|
||||
@@ -2725,16 +2650,7 @@ async fn configuration_answer_resyncs_open_documents_of_opted_in_servers() {
|
||||
.await;
|
||||
assert_eq!(s.notified("textDocument/didChange").len(), 2, "one re-sync per answer");
|
||||
let methods: Vec<String> = extra.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
|
||||
assert_eq!(
|
||||
methods,
|
||||
[
|
||||
"initialized",
|
||||
"workspace/didChangeConfiguration",
|
||||
"textDocument/didOpen",
|
||||
"textDocument/didChange",
|
||||
"textDocument/didSave"
|
||||
]
|
||||
);
|
||||
assert_eq!(methods, ["initialized", "textDocument/didOpen", "textDocument/didChange", "textDocument/didSave"]);
|
||||
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
@@ -2790,9 +2706,9 @@ async fn settings_changes_reach_servers_without_restarts() {
|
||||
let s = h.launcher.state("mock");
|
||||
*settings.lock() = Some(json!({ "nested": { "other": 2 } }));
|
||||
h.mgr.reconfigure().await;
|
||||
eventually(|| s.notified("workspace/didChangeConfiguration").len() == 2).await;
|
||||
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
|
||||
assert_eq!(
|
||||
s.notified("workspace/didChangeConfiguration")[1],
|
||||
s.notified("workspace/didChangeConfiguration")[0],
|
||||
json!({ "settings": { "flag": true, "nested": { "deep": 1, "other": 2 } } })
|
||||
);
|
||||
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
|
||||
|
||||
@@ -462,54 +462,35 @@ fn main() {
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires ty on PATH"]
|
||||
async fn ty_python_end_to_end() {
|
||||
python_server_end_to_end("ty").await;
|
||||
}
|
||||
|
||||
/// Pyright loads the workspace only after `workspace/didChangeConfiguration`.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires pyright-langserver on PATH"]
|
||||
async fn pyright_python_end_to_end() {
|
||||
python_server_end_to_end("pyright").await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires basedpyright on PATH"]
|
||||
async fn basedpyright_python_end_to_end() {
|
||||
python_server_end_to_end("basedpyright").await;
|
||||
}
|
||||
|
||||
/// Definition and diagnostics from `name` alone, in a project without configuration.
|
||||
async fn python_server_end_to_end(name: &str) {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path().canonicalize().unwrap();
|
||||
let path = root.join("example.py");
|
||||
let source = "def greet(name: str) -> str:\n return name\n\nresult = greet('Ada')\nbad: int = 'wrong'\n";
|
||||
std::fs::write(&path, source).unwrap();
|
||||
let mut python = LanguageRegistry::load(None).unwrap().get(&LanguageId::new("python")).unwrap();
|
||||
python.language_servers.retain(|server| server.name == name);
|
||||
python.language_servers.retain(|server| server.name == "ty");
|
||||
assert_eq!(python.language_servers.len(), 1);
|
||||
python.language_servers[0].fallback = false;
|
||||
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![python]));
|
||||
let doc = DocId::next();
|
||||
mgr.did_open(doc, &path, &LanguageId::new("python"), 1, source);
|
||||
retry(&format!("{name} ready"), Duration::from_secs(30), || {
|
||||
let status = last_status(&events, name);
|
||||
retry("ty ready", Duration::from_secs(30), || {
|
||||
let status = last_status(&events, "ty");
|
||||
if let Some((ServerStatus::Crashed | ServerStatus::Missing | ServerStatus::Misconfigured, msg)) = &status {
|
||||
panic!("{name} failed: {msg:?}");
|
||||
panic!("ty failed: {msg:?}");
|
||||
}
|
||||
async move { matches!(status, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }
|
||||
})
|
||||
.await;
|
||||
let defs = retry(&format!("{name} definition"), Duration::from_secs(30), || {
|
||||
let defs = retry("ty definition", Duration::from_secs(30), || {
|
||||
let mgr = mgr.clone();
|
||||
async move { mgr.goto(doc, Pos::new(3, 10), GotoKind::Definition).await.ok().filter(|d| !d.is_empty()) }
|
||||
})
|
||||
.await;
|
||||
assert_eq!(defs[0].path, path);
|
||||
assert_eq!(defs[0].range.start.line, 0);
|
||||
retry(&format!("{name} diagnostics"), Duration::from_secs(30), || {
|
||||
retry("ty diagnostics", Duration::from_secs(30), || {
|
||||
let found = events.lock().iter().any(
|
||||
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == name && !items.is_empty()),
|
||||
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == "ty" && !items.is_empty()),
|
||||
);
|
||||
async move { found.then_some(()) }
|
||||
})
|
||||
|
||||
@@ -1649,7 +1649,7 @@ pub fn jvm_inspect_bundle(data_dir: &Path) -> Option<PathBuf> {
|
||||
install_bundle(
|
||||
data_dir,
|
||||
"jvm-inspect",
|
||||
"1.1.1",
|
||||
"1.1.0",
|
||||
include_bytes!("../../../java/jvm-inspect/openidea-jvm-inspect.jar"),
|
||||
)
|
||||
}
|
||||
@@ -1745,7 +1745,7 @@ mod usages_bundle_tests {
|
||||
std::fs::write(dir.path().join(name), b"old").unwrap();
|
||||
}
|
||||
let jar = super::jvm_inspect_bundle(dir.path()).unwrap();
|
||||
assert_eq!(jar, dir.path().join("jvm-inspect-1.1.1.jar"));
|
||||
assert_eq!(jar, dir.path().join("jvm-inspect-1.1.0.jar"));
|
||||
assert_eq!(std::fs::read(&jar).unwrap(), include_bytes!("../../../java/jvm-inspect/openidea-jvm-inspect.jar"));
|
||||
assert!(!dir.path().join("jvm-inspect-0.9.0.jar").exists());
|
||||
assert_eq!(std::fs::read(dir.path().join("java-usages-1.7.0.jar")).unwrap(), b"old");
|
||||
|
||||
@@ -197,62 +197,28 @@ 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))
|
||||
}
|
||||
|
||||
/// 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>)>;
|
||||
/// 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 = |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
|
||||
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 dict.clone();
|
||||
return words.clone();
|
||||
}
|
||||
let read = |p: &Path| {
|
||||
std::fs::read_to_string(p).map_err(|e| tracing::debug!("custom dictionary {}: {e}", p.display())).ok()
|
||||
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()
|
||||
}
|
||||
};
|
||||
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
|
||||
let words = Arc::new(words);
|
||||
cache.insert(path.to_path_buf(), (modified, words.clone()));
|
||||
words
|
||||
}
|
||||
|
||||
/// Lowercased words of a word list / Hunspell `.dic` text.
|
||||
@@ -272,7 +238,7 @@ pub fn parse_word_list(text: &str) -> HashSet<String> {
|
||||
#[derive(Default)]
|
||||
pub struct Speller {
|
||||
accepted: HashSet<String>,
|
||||
custom: Vec<Arc<CustomDictionary>>,
|
||||
custom: Vec<Arc<HashSet<String>>>,
|
||||
}
|
||||
|
||||
impl Speller {
|
||||
@@ -385,31 +351,16 @@ impl Speller {
|
||||
&& !near_word(lower, |w| english().check(w))
|
||||
}
|
||||
|
||||
/// Replacements for `word`, best first, in the word's case style: from the
|
||||
/// English dictionary and the custom Hunspell dictionaries, the closest first.
|
||||
/// Replacements for `word`, best first, in the word's case style.
|
||||
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();
|
||||
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);
|
||||
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();
|
||||
}
|
||||
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
|
||||
}
|
||||
@@ -465,22 +416,6 @@ 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()
|
||||
@@ -801,36 +736,6 @@ mod tests {
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hunspell_custom_dictionaries_use_their_affix_rules() {
|
||||
let dir = std::env::temp_dir().join(format!("ide-spell-hunspell-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let dic = dir.join("de_TEST.dic");
|
||||
std::fs::write(&dic, "3\nhaus/NZ\ntür/NZ\nschlüssel/Z\n").unwrap();
|
||||
std::fs::write(
|
||||
dir.join("de_TEST.aff"),
|
||||
"SET UTF-8\nTRY esianrtolcdugmphbyfvkwzäöüß\nCOMPOUNDFLAG Z\nSFX N Y 1\nSFX N 0 en .\n",
|
||||
)
|
||||
.unwrap();
|
||||
let s = Speller::new::<&str>([], std::slice::from_ref(&dic));
|
||||
// Affix rules, compounds and case styles of the .aff, not just the listed stems.
|
||||
for word in ["haus", "Haus", "hausen", "türen", "Haustür", "schlüsselhaus"] {
|
||||
assert!(s.is_correct(word), "{word}");
|
||||
}
|
||||
assert!(!s.is_correct("hauz"));
|
||||
assert!(!s.is_correct("schlüsselen"));
|
||||
assert!(s.suggest("Hauss", 5).iter().any(|w| w == "Haus"), "{:?}", s.suggest("Hauss", 5));
|
||||
// English still checks and suggests.
|
||||
assert!(s.is_correct("message"));
|
||||
assert!(s.suggest("mesage", 5).iter().any(|w| w == "message"));
|
||||
// Without its .aff, a .dic is a word list.
|
||||
std::fs::remove_file(dir.join("de_TEST.aff")).unwrap();
|
||||
let words = Speller::new::<&str>([], std::slice::from_ref(&dic));
|
||||
assert!(words.is_correct("haus"));
|
||||
assert!(!words.is_correct("hausen"));
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn utf16_ranges() {
|
||||
let s = Speller::default();
|
||||
|
||||
@@ -372,8 +372,6 @@ fn materialize_row(
|
||||
if let Some((pos, total)) = position {
|
||||
commit.log_position = Some(pos);
|
||||
commit.log_total = Some(total);
|
||||
let merge_time_ms = row.merge_time_secs as f64 * 1000.0;
|
||||
commit.log_merge_time_ms = (merge_time_ms > commit.commit_time_ms).then_some(merge_time_ms);
|
||||
}
|
||||
if !summary_only {
|
||||
commit.message = index.message(repo, row.id)?;
|
||||
@@ -716,16 +714,17 @@ fn log_indexed_rows(
|
||||
skip -= 1;
|
||||
continue;
|
||||
}
|
||||
let (parents, commit_time_secs) = if let Some((parents, time)) = visibility.index.nodes.get(&id) {
|
||||
(parents.clone(), *time)
|
||||
let parents: Vec<ObjectId> = if shallow.contains(&id) {
|
||||
Vec::new()
|
||||
} else if let Some((ps, _)) = visibility.index.nodes.get(&id) {
|
||||
ps.clone()
|
||||
} else {
|
||||
let record = visibility.index.get_with_table(&repo, id, visibility.table)?;
|
||||
let parents = record
|
||||
record
|
||||
.parents
|
||||
.iter()
|
||||
.map(|p| ObjectId::from_hex(p.as_bytes()).map_err(gx))
|
||||
.collect::<IdeResult<Vec<_>>>()?;
|
||||
(parents, (record.commit_time_ms / 1000.0) as i64)
|
||||
.collect::<IdeResult<Vec<_>>>()?
|
||||
};
|
||||
let shown_parents = if shallow.contains(&id) {
|
||||
Vec::new()
|
||||
@@ -744,7 +743,6 @@ fn log_indexed_rows(
|
||||
graph_parents: shown_parents,
|
||||
on_current_branch,
|
||||
history_path: history_paths.get(&id).cloned(),
|
||||
merge_time_secs: commit_time_secs,
|
||||
});
|
||||
if out.len() >= limit || stop_id == Some(id) {
|
||||
break;
|
||||
|
||||
@@ -125,9 +125,6 @@ pub struct Commit {
|
||||
pub log_position: Option<u32>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub log_total: Option<u32>,
|
||||
/// Newest committer time at or after this row if newer than the row's commit.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub log_merge_time_ms: Option<f64>,
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub graph_boundary_parents: Vec<String>,
|
||||
/// Reachability from HEAD, computed independently of the visible filters.
|
||||
|
||||
@@ -19,16 +19,12 @@ const MESSAGES: TableDefinition<&str, &str> = TableDefinition::new("messages-v1"
|
||||
const MAX_MEMORY_COMMITS: usize = 4096;
|
||||
const MAX_MEMORY_MESSAGES: usize = 1024;
|
||||
const MAX_DIRTY_BATCH: usize = 16_384;
|
||||
/// redb's page cache, which otherwise grows to 1 GiB per repository. Hot commits are already
|
||||
/// kept in `memory`.
|
||||
const DB_CACHE_BYTES: usize = 32 * 1024 * 1024;
|
||||
|
||||
pub(crate) struct IndexedRow {
|
||||
pub id: ObjectId,
|
||||
pub graph_parents: Vec<ObjectId>,
|
||||
pub on_current_branch: bool,
|
||||
pub history_path: Option<String>,
|
||||
pub merge_time_secs: i64,
|
||||
}
|
||||
|
||||
pub(crate) struct IndexedView {
|
||||
@@ -36,15 +32,8 @@ pub(crate) struct IndexedView {
|
||||
pub positions: HashMap<ObjectId, usize>,
|
||||
}
|
||||
impl IndexedView {
|
||||
pub fn new(mut rows: Vec<IndexedRow>) -> Self {
|
||||
let mut positions = HashMap::with_capacity(rows.len());
|
||||
let mut latest = i64::MIN;
|
||||
// Compute priority across the whole log so it stays the same on every page.
|
||||
for (i, row) in rows.iter_mut().enumerate().rev() {
|
||||
latest = latest.max(row.merge_time_secs);
|
||||
row.merge_time_secs = latest;
|
||||
positions.insert(row.id, i);
|
||||
}
|
||||
pub fn new(rows: Vec<IndexedRow>) -> Self {
|
||||
let positions = rows.iter().enumerate().map(|(i, r)| (r.id, i)).collect();
|
||||
Self { rows, positions }
|
||||
}
|
||||
}
|
||||
@@ -280,11 +269,7 @@ 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::builder().set_cache_size(DB_CACHE_BYTES).create(&path).ok())?,
|
||||
);
|
||||
let db = Arc::new(std::fs::create_dir_all(dir).ok().and_then(|_| Database::create(&path).ok())?);
|
||||
drop_stale_tables(&db);
|
||||
databases.insert(path, Arc::downgrade(&db));
|
||||
Some(db)
|
||||
@@ -349,7 +334,6 @@ impl LogIndex {
|
||||
history_path: None,
|
||||
log_position: None,
|
||||
log_total: None,
|
||||
log_merge_time_ms: None,
|
||||
graph_boundary_parents: Vec::new(),
|
||||
refs: Vec::new(),
|
||||
});
|
||||
|
||||
@@ -1155,31 +1155,16 @@ fn check_rev(rev: &str) -> IdeResult<&str> {
|
||||
Ok(rev)
|
||||
}
|
||||
|
||||
/// The short name of a full branch ref (`refs/heads/x`, `refs/remotes/origin/x`) when it
|
||||
/// names that same branch: git writes the name it is given into the merge message and the
|
||||
/// reflog. A name a tag shares stays a full ref, the case IDEA also passes in full.
|
||||
fn unambiguous_branch_name<'a>(r: &Repo, rev: &'a str) -> &'a str {
|
||||
let Some(short) = rev.strip_prefix("refs/heads/").or_else(|| rev.strip_prefix("refs/remotes/")) else {
|
||||
return rev;
|
||||
};
|
||||
// An ambiguous name prints nothing (git reports it on stderr).
|
||||
let full = cli::run_raw(r.root(), &["rev-parse", "--verify", "-q", "--symbolic-full-name", short], None);
|
||||
match full {
|
||||
Ok(out) if out.code == Some(0) && out.stdout_str().trim() == rev => short,
|
||||
_ => rev,
|
||||
}
|
||||
}
|
||||
|
||||
/// Local changes are stashed and restored around the merge (IDEA's "save local changes").
|
||||
pub(crate) fn merge(r: &Repo, branch: &str) -> IdeResult<()> {
|
||||
let branch = unambiguous_branch_name(r, check_rev(branch)?);
|
||||
let branch = check_rev(branch)?;
|
||||
crate::preserve::around(r, "Local changes saved before merge", || {
|
||||
run(r.root(), &["merge", "--no-edit", branch], None).map(|_| ())
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn rebase(r: &Repo, onto: &str) -> IdeResult<()> {
|
||||
let onto = unambiguous_branch_name(r, check_rev(onto)?);
|
||||
let onto = check_rev(onto)?;
|
||||
crate::preserve::around(r, "Local changes saved before rebase", || {
|
||||
run(r.root(), &["rebase", onto], None).map(|_| ())
|
||||
})
|
||||
|
||||
@@ -505,37 +505,6 @@ fn rebase_and_merge_onto_a_branch_named_like_a_tag_use_the_branch() {
|
||||
assert_eq!(fx.head(), tip, "fast-forwarded to the branch, not the tag");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn merge_and_rebase_record_the_branch_name_git_would_show() {
|
||||
let (fx, _bare) = Fixture::with_origin();
|
||||
fx.git(&["switch", "-q", "-c", "topic"]);
|
||||
fx.write("t.txt", "t\n");
|
||||
fx.commit_all("topic");
|
||||
fx.git(&["push", "-q", "origin", "topic"]);
|
||||
fx.git(&["switch", "-q", "main"]);
|
||||
fx.write("m.txt", "m\n");
|
||||
fx.commit_all("main");
|
||||
let repo = fx.repo();
|
||||
let subject = || fx.git(&["log", "-1", "--format=%s"]);
|
||||
|
||||
repo.merge("refs/heads/topic").unwrap();
|
||||
assert_eq!(subject(), "Merge branch 'topic'");
|
||||
fx.git(&["reset", "-q", "--hard", "HEAD~1"]);
|
||||
repo.merge("refs/remotes/origin/topic").unwrap();
|
||||
assert_eq!(subject(), "Merge remote-tracking branch 'origin/topic'");
|
||||
fx.git(&["reset", "-q", "--hard", "HEAD~1"]);
|
||||
|
||||
repo.rebase("refs/heads/topic").unwrap();
|
||||
let reflog = fx.git(&["reflog", "--format=%gs"]);
|
||||
assert!(reflog.contains("rebase (start): checkout topic"), "{reflog}");
|
||||
fx.git(&["reset", "-q", "--hard", "ORIG_HEAD"]);
|
||||
|
||||
// A tag of the same name makes the short name ambiguous: the full ref stays.
|
||||
fx.git(&["tag", "topic", "main~1"]);
|
||||
repo.merge("refs/heads/topic").unwrap();
|
||||
assert_eq!(subject(), "Merge branch 'refs/heads/topic'");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn interactive_rebase_edit_stops_for_amend() {
|
||||
let (fx, ids) = linear();
|
||||
|
||||
@@ -83,28 +83,6 @@ fn incoming_order_groups_the_merged_branch_before_the_main_parent() {
|
||||
assert_eq!(out[1].parents, vec![h.c2.clone(), h.s1.clone()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_older_incoming_tip_uses_the_later_commit_time_when_merging_repo_pages() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let dir = tmp.path();
|
||||
git(dir, &["init", "-q"], None);
|
||||
let base = commit(dir, "base.txt", "base", 1000);
|
||||
let recent = commit(dir, "recent.txt", "recent", 4000);
|
||||
git(dir, &["checkout", "-qb", "incoming", &base], None);
|
||||
let incoming = commit(dir, "incoming.txt", "incoming", 2000);
|
||||
git(dir, &["checkout", "-q", "main"], None);
|
||||
let repo = Repo::discover(dir).unwrap().unwrap();
|
||||
let query = LogQuery { summary_only: true, order: LogOrder::Standard, limit: 1, ..Default::default() };
|
||||
|
||||
let first = repo.log(&query).unwrap();
|
||||
assert_eq!(first[0].id, incoming);
|
||||
assert_eq!(first[0].commit_time_ms, 2_000_000.0);
|
||||
assert_eq!(first[0].log_merge_time_ms, Some(4_000_000.0));
|
||||
let next = repo.log(&LogQuery { skip: 1, ..query }).unwrap();
|
||||
assert_eq!(next[0].id, recent);
|
||||
assert_eq!(next[0].log_merge_time_ms, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_merges_links_children_to_the_merge_parents() {
|
||||
let h = history();
|
||||
|
||||
@@ -86,7 +86,6 @@ Each crate's `lib.rs` opens with a module doc comment describing its contract; r
|
||||
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `ide-cli` | The `openidea` command: argument parsing, the request it sends to a running app over a local socket, installing it on `PATH`. |
|
||||
| `ide-clipboard` | The OS clipboard's file list (Windows `CF_HDROP`, macOS `NSPasteboard` file URLs) for copying files between the Project view and the file manager. |
|
||||
| `ide-drag-out` | OS file drags out of a window (GTK, OLE, AppKit), so files dragged from the Project view to another app are copied there. |
|
||||
| `ide-fonts` | Installed font families for the font pickers, via CoreText, DirectWrite or fontconfig. |
|
||||
| `src-tauri` (package `openidea`) | The desktop shell: `AppState`, Tauri commands, the event sink, windows, menus, the remote-development client, the `openidea-plugin` URL scheme for plugin web views. Glue only. |
|
||||
|
||||
|
||||
@@ -125,7 +125,7 @@ Tasks are saved per project and survive restarts. When the agent supports resumi
|
||||
|
||||
**Settings › Tools › Agents** (also **More Agents…** in the agent picker) has two tabs:
|
||||
|
||||
- **Built-in**: for each built-in agent, whether its executable was found on `PATH`, a field to point at a **Custom executable**, **Environment variables** for the agent process (written as `NAME=value; OTHER=value`; the values are kept in the OS credential store) and how to sign in. Changes apply to new sessions. 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.
|
||||
- **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.
|
||||
- **ACP Registry**: agents published in the [ACP Registry](https://agentclientprotocol.com). Search, **Install**, **Update** and **Remove**. Installed agents are kept in OpenIDEA's data directory; downloads are checked against the registry's SHA-256 when it provides one.
|
||||
|
||||
**Settings › Tools › Agents › Chat** chooses what the task header shows: **Context window usage**, **Time spent on the task**, **Usage limits** (when the agent reports them, such as Claude Code) and **Session cost**.
|
||||
|
||||
@@ -57,7 +57,6 @@ Language servers that support LSP inline completion show a grey suggestion at th
|
||||
| **Next Method** / **Previous Method** | `⌃⇧↓` / `⌃⇧↑` | `Alt+Down` / `Alt+Up` |
|
||||
|
||||
- **Go to Declaration or Usages** on a declaration shows its usages instead.
|
||||
- **Go to Implementation(s)** navigates to the symbol's own declaration when it has no implementations, as in IntelliJ IDEA.
|
||||
- Hold `⌘` / `Ctrl` and hover over a name to see it underlined as a link, with brief information about it.
|
||||
- Gutter icons mark types and methods that are implemented or overridden (↓) and methods that implement or override another (↑). Click one to go there.
|
||||
- **Navigate › Test** jumps between a class and its tests by naming convention and offers **Create New Test…** when there is none.
|
||||
|
||||
@@ -172,13 +172,11 @@ The export button offers **Export Data…** and quick copies: **Copy as CSV**, *
|
||||
|
||||
The built-in HTTP driver uses a named session by default (`use_http_session=true`). Route requests to one node or enable session affinity. If the session expires or another node reports code 372, OpenIDEA shows a reconnect error and never replays the statement.
|
||||
|
||||
For endpoints that route each request to a different node, add **Advanced** property `use_http_session` with value `false`. Each request omits `session_id`, `session_check` and `session_timeout`, and sends the configured database (or **Default schema**), time zone and Advanced settings again. **Read-only** sends `readonly=1` on every request.
|
||||
For endpoints that route each request to a different node, add **Advanced** property `use_http_session` with value `false`. Each request omits `session_id`, `session_check` and `session_timeout`, and sends the configured database (or **Default schema**), time zone and Advanced settings again. **Read-only** sends `readonly=1` on every request; result-limit settings remain enabled.
|
||||
|
||||
Stateless statements must be independent: `USE`, standalone `SET`, temporary tables and other session state cannot carry over to later requests. Configure the database and settings on the data source. Startup scripts and explicit session properties (`session_id`, `session_check`, `session_timeout`) are rejected. SQL transactions and statement caching are unsupported in either mode.
|
||||
|
||||
For strict read-only accounts behind a load balancer, set `use_http_session=false` and enable **Read-only**. If the initial connection check receives ClickHouse code 164 for a driver-managed result setting, OpenIDEA repeats the check without its result-limit and JSON number-format settings. Each request still sends `readonly=1`, and the grid still retains only the requested page. Configure server-side limits in the account's settings profile. With the server's default JSON settings, `NaN` and infinities may appear as `NULL`.
|
||||
|
||||
Use consistent account profiles across replicas. If the first node accepts the driver's result settings and a later node rejects them, OpenIDEA reports the error on that request. Connect again after aligning the profiles.
|
||||
Strict read-only servers that refuse per-request driver settings cannot use stateless mode: the connection fails without dropping read-only protection or limits. The strict read-only fallback requires proof in the same named HTTP session, including on subsequent requests; use one node or session affinity.
|
||||
|
||||
## Oracle
|
||||
|
||||
|
||||
@@ -112,7 +112,7 @@ The debugger adds attach-only types such as **Remote JVM Debug**, **Go Remote**,
|
||||
### Common fields
|
||||
|
||||
- **Run on**: the local machine, or an SSH host defined in **Settings › Build, Execution, Deployment › Run Targets**. Debugging is not available on run targets. See [SSH](/en/guide/remote/ssh).
|
||||
- **Working directory**: relative to the project root; empty means the project root. 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.
|
||||
- **Working directory**: relative to the project root; empty means the project root.
|
||||
- **Environment variables**: `VAR=value` pairs separated by `;`. The list button opens the **Environment Variables** dialog, where **Include system environment variables** can be turned off.
|
||||
- **Debug adapter**: which debugger **Debug** uses for this configuration (for example `debugpy`, `js-debug`, `codelldb`, `delve`).
|
||||
|
||||
|
||||
@@ -23,7 +23,7 @@ Only types you add appear here: choose **Add Service › Run Configuration Type*
|
||||
- Configuration actions: **Run** (or **Rerun**), **Debug**, **Stop**, **Open in Browser**, **Update Application** (for configurations that support it).
|
||||
- Context menu: **Show in Run Tool Window**, **Show in Debug Tool Window**, **Edit Configuration…**, **Remove from Services**.
|
||||
|
||||
A configuration that ran shows its console in the detail pane; 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.
|
||||
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.
|
||||
|
||||
## Docker
|
||||
|
||||
|
||||
@@ -86,7 +86,6 @@ Cargo workspace 由 `crates/*` 加 `src-tauri` 组成(见根目录 `Cargo.toml
|
||||
| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `ide-cli` | `openidea` 命令:参数解析、通过本地 socket 发给运行中应用的请求、安装到 `PATH`。 |
|
||||
| `ide-clipboard` | 操作系统剪贴板里的文件列表(Windows `CF_HDROP`、macOS `NSPasteboard` 文件 URL),用于 Project 视图与文件管理器之间复制文件。 |
|
||||
| `ide-drag-out` | 从窗口发起操作系统文件拖放(GTK、OLE、AppKit),从 Project 视图拖到其他程序的文件由该程序复制。 |
|
||||
| `ide-fonts` | 已安装的字体族,供字体选择器使用,分别通过 CoreText、DirectWrite 或 fontconfig 获取。 |
|
||||
| `src-tauri`(包名 `openidea`) | 桌面外壳:`AppState`、Tauri 命令、事件 sink、窗口、菜单、远程开发客户端、插件 Web 视图用的 `openidea-plugin` URL scheme。只做胶水。 |
|
||||
|
||||
|
||||
@@ -125,7 +125,7 @@ agent 运行过一个任务后,新任务会以它自动批准所有操作的
|
||||
|
||||
**设置 › 工具 › 智能体**(也可以在 agent 选择器中点 **更多 Agent…**)有两个标签页:
|
||||
|
||||
- **内置**:每个内置 agent 的可执行文件是否在 `PATH` 中找到、指定 **自定义可执行文件** 的输入框、传给 agent 进程的 **环境变量**(格式为 `NAME=value; OTHER=value`;这些值保存在系统凭据存储中)以及登录方式。改动对新会话生效。如果 agent 是 npm 全局安装(例如 Claude Code、Codex、Gemini CLI),**检查更新** 会与 npm 的最新稳定版比较,点击 **更新至…** 即可更新这份安装。
|
||||
- **内置**:每个内置 agent 的可执行文件是否在 `PATH` 中找到、指定 **自定义可执行文件** 的输入框、传给 agent 进程的 **环境变量**(格式为 `NAME=value; OTHER=value`;这些值保存在系统凭据存储中)以及登录方式。改动对新会话生效。
|
||||
- **ACP 注册表**:[ACP Registry](https://agentclientprotocol.com) 中发布的 agent,可以搜索、**安装**、**更新** 和 **移除**。安装的 agent 保存在 OpenIDEA 的数据目录中;注册表提供 SHA-256 时会校验下载内容。
|
||||
|
||||
**设置 › 工具 › 智能体 › 聊天** 决定任务标题栏显示哪些信息:**上下文窗口用量**、**任务耗时**、**用量限额**(agent 报告时,例如 Claude Code)和 **会话花费**。
|
||||
|
||||
@@ -57,7 +57,6 @@ description: "代码补全、导航、查找用法、文档、层次结构与文
|
||||
| **下一个方法** / **上一个方法** | `⌃⇧↓` / `⌃⇧↑` | `Alt+Down` / `Alt+Up` |
|
||||
|
||||
- 在声明本身上执行 **转到声明或用法**,会改为显示它的用法。
|
||||
- 没有任何实现时,**转到实现** 会跳转到符号自身的声明,与 IntelliJ IDEA 一致。
|
||||
- 按住 `⌘` / `Ctrl` 把鼠标悬停在名称上,名称会显示为链接,并附带简要信息。
|
||||
- 装订区域的图标标出被实现或被重写的类型和方法(↓),以及实现或重写了其他方法的方法(↑),单击即可跳转。
|
||||
- **导航 › 测试** 按命名约定在类和它的测试之间跳转;还没有测试时会提供 **创建新测试…**。
|
||||
|
||||
@@ -171,13 +171,11 @@ SQL 补全基于已连接的架构:`FROM`/`JOIN` 后补全表(并根据外
|
||||
|
||||
内置 HTTP 驱动默认使用命名会话(`use_http_session=true`)。请求应路由到同一节点,或启用会话亲和性。如果会话过期或其他节点返回代码 372,OpenIDEA 会提示重新连接,且不会重放语句。
|
||||
|
||||
如果端点把每个请求路由到不同节点,可在 **高级** 中添加属性 `use_http_session`,值设为 `false`。每个请求都省略 `session_id`、`session_check` 和 `session_timeout`,并重新发送配置的数据库(或 **默认架构**)、时区及高级设置。启用 **只读** 时,每个请求都发送 `readonly=1`。
|
||||
如果端点把每个请求路由到不同节点,可在 **高级** 中添加属性 `use_http_session`,值设为 `false`。每个请求都省略 `session_id`、`session_check` 和 `session_timeout`,并重新发送配置的数据库(或 **默认架构**)、时区及高级设置。启用 **只读** 时,每个请求都发送 `readonly=1`;结果行数限制设置也会保留。
|
||||
|
||||
无会话模式下,每条语句必须独立:`USE`、独立的 `SET`、临时表及其他会话状态无法延续到后续请求。请在数据源中配置数据库和设置。驱动会拒绝启动脚本以及显式会话属性(`session_id`、`session_check`、`session_timeout`)。两种模式均不支持 SQL 事务和语句缓存。
|
||||
|
||||
对于负载均衡器后的严格只读账户,请设置 `use_http_session=false` 并启用 **只读**。如果初次连接检查因驱动管理的结果设置收到 ClickHouse 错误码 164,OpenIDEA 会省略驱动的结果行数限制和 JSON 数字格式设置,再进行一次连接检查。每个请求仍会发送 `readonly=1`,结果表格仍只保留所请求的一页。请在账户的设置配置文件中配置服务端限制。使用服务器的默认 JSON 设置时,`NaN` 和无穷值可能显示为 `NULL`。
|
||||
|
||||
请在各副本上使用一致的账户设置配置文件。如果第一个节点接受驱动的结果设置,后续节点拒绝这些设置,OpenIDEA 会报告该请求的错误。调整配置文件使其一致后再连接。
|
||||
拒绝逐请求驱动设置的严格只读服务器无法使用无会话模式:连接会失败,不会移除只读保护或限制。严格只读回退必须在同一个命名 HTTP 会话中验证,后续请求也必须使用该会话;请使用单一节点或会话亲和性。
|
||||
|
||||
## Oracle
|
||||
|
||||
|
||||
@@ -108,7 +108,7 @@ description: "创建、编辑和启动运行配置,从装订区运行代码,
|
||||
### 通用字段
|
||||
|
||||
- **运行于**:本地计算机,或在 **设置 › 构建、执行、部署 › 运行目标** 中添加的 SSH 主机。运行目标上不支持调试。参见 [SSH](/zh/guide/remote/ssh)。
|
||||
- **工作目录**:相对于项目根目录,留空即项目根目录。可以使用路径宏 `$PROJECT_DIR$`、`$ContentRoot$`、`$MODULE_DIR$`、`$MODULE_WORKING_DIR$` 和 `$USER_HOME$`,在配置启动时展开,因此共享的配置在每台机器上都能用。
|
||||
- **工作目录**:相对于项目根目录,留空即项目根目录。
|
||||
- **环境变量**:`VAR=value` 形式,用 `;` 分隔。点旁边的列表按钮打开“环境变量”对话框,可以关闭 **包括系统环境变量**。
|
||||
- **调试适配器**:按“调试”时这个配置使用哪个调试器(如 `debugpy`、`js-debug`、`codelldb`、`delve`)。
|
||||
|
||||
|
||||
@@ -23,7 +23,7 @@ description: "在服务工具窗口中管理运行配置、Docker 容器、镜
|
||||
- 配置操作:**运行**(或 **重新运行**)、**调试**、**停止**、**在浏览器中打开**、**更新应用**(仅支持的配置)。
|
||||
- 右键菜单:**在运行工具窗口中显示**、**在调试工具窗口中显示**、**编辑配置…**、**从服务中移除**。
|
||||
|
||||
运行过的配置会在详情区显示其控制台;从这里调试的配置在详情区显示完整的调试器(线程和变量、控制台、内存),命中断点时停留在服务工具窗口。在同一分组内可以拖动或用 **上移** / **下移** 调整顺序,顺序按项目保存。
|
||||
运行过的配置会在详情区显示其控制台。在同一分组内可以拖动或用 **上移** / **下移** 调整顺序,顺序按项目保存。
|
||||
|
||||
## Docker
|
||||
|
||||
|
||||
@@ -1,88 +0,0 @@
|
||||
import type { Page } from "@playwright/test";
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
async function openSaveActions(page: Page) {
|
||||
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("Optimize imports");
|
||||
await settings.getByRole("treeitem", { name: "Actions on Save", exact: true }).click();
|
||||
await search.clear();
|
||||
return settings;
|
||||
}
|
||||
|
||||
test("Actions on Save aligns each enabled action with its trigger in wide and narrow panes", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const settings = await openSaveActions(page);
|
||||
const table = settings.getByRole("table", { name: "Actions on Save", exact: true });
|
||||
const action = table.getByRole("columnheader", { name: "Action", exact: true });
|
||||
const heading = table.getByRole("columnheader", { name: "Activated on", exact: true });
|
||||
const format = table.getByRole("row", { name: /Reformat code/ });
|
||||
const imports = table.getByRole("row", { name: /Optimize imports/ });
|
||||
const cleanup = table.getByRole("row", { name: /Run code cleanup/ });
|
||||
const trigger = (action: typeof format) => action.getByRole("cell").nth(1);
|
||||
await expect(table.getByRole("row")).toHaveCount(4);
|
||||
await format.getByRole("checkbox").check();
|
||||
await imports.getByRole("checkbox").press("Space");
|
||||
await expect(trigger(format)).toHaveText("Save or Save All");
|
||||
await expect(trigger(imports)).toHaveText("Save or Save All");
|
||||
await expect(trigger(cleanup)).toBeEmpty();
|
||||
|
||||
for (const width of [1120, 520]) {
|
||||
await page.setViewportSize({ width, height: 740 });
|
||||
await expect(heading).toBeInViewport({ ratio: 1 });
|
||||
await expect(trigger(imports)).toBeInViewport({ ratio: 1 });
|
||||
const column = (await heading.boundingBox())!;
|
||||
expect((await action.boundingBox())!.width).toBeGreaterThan(column.width);
|
||||
expect(
|
||||
await trigger(imports).evaluate((cell) => {
|
||||
const range = document.createRange();
|
||||
range.selectNodeContents(cell.firstElementChild!);
|
||||
return range.getClientRects().length;
|
||||
}),
|
||||
).toBe(1);
|
||||
for (const row of [format, imports, cleanup]) {
|
||||
const cell = (await trigger(row).boundingBox())!;
|
||||
expect(Math.abs(column.x - cell.x)).toBeLessThan(1);
|
||||
expect(Math.abs(column.width - cell.width)).toBeLessThan(1);
|
||||
}
|
||||
expect(await table.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await expect(settings.getByRole("button", { name: "Editor › General", exact: true })).toBeInViewport();
|
||||
}
|
||||
|
||||
await format.getByRole("checkbox").uncheck();
|
||||
await expect(trigger(format)).toBeEmpty();
|
||||
await expect(trigger(imports)).toHaveText("Save or Save All");
|
||||
});
|
||||
|
||||
test("Actions on Save stages the same preferences as Editor General and honors Apply and Cancel", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const settings = await openSaveActions(page);
|
||||
const format = settings.getByRole("checkbox", { name: "Reformat code", exact: true });
|
||||
const imports = settings.getByRole("checkbox", { name: "Optimize imports", exact: true });
|
||||
const cleanup = settings.getByRole("checkbox", { name: "Run code cleanup", exact: true });
|
||||
const apply = settings.getByRole("button", { name: "Apply", exact: true });
|
||||
const cancel = settings.getByRole("button", { name: "Cancel", exact: true });
|
||||
await format.check();
|
||||
await imports.check();
|
||||
await settings.getByRole("button", { name: "Editor › General", exact: true }).click();
|
||||
await expect(settings.getByRole("checkbox", { name: "Reformat code on save", exact: true })).toBeChecked();
|
||||
await settings.getByRole("button", { name: "Back", exact: true }).click();
|
||||
await expect(format).toBeChecked();
|
||||
await expect(imports).toBeChecked();
|
||||
await apply.click();
|
||||
await expect(apply).toBeDisabled();
|
||||
await cancel.click();
|
||||
|
||||
await openSaveActions(page);
|
||||
await expect(format).toBeChecked();
|
||||
await expect(imports).toBeChecked();
|
||||
await cleanup.check();
|
||||
await cancel.click();
|
||||
await openSaveActions(page);
|
||||
await expect(cleanup).not.toBeChecked();
|
||||
await expect(format).toBeChecked();
|
||||
await expect(imports).toBeChecked();
|
||||
});
|
||||
@@ -1,85 +0,0 @@
|
||||
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");
|
||||
});
|
||||
}
|
||||
@@ -1,80 +0,0 @@
|
||||
import type { Page } from "@playwright/test";
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
async function openCompletionSettings(page: Page) {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const search = dialog.getByRole("textbox", { name: "Search settings" });
|
||||
await search.fill("First letter only");
|
||||
await dialog.getByRole("treeitem", { name: "Code Completion", exact: true }).click();
|
||||
await search.clear();
|
||||
return dialog;
|
||||
}
|
||||
|
||||
test("Code Completion puts both case-matching choices beside the checkbox and keeps them in view", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 1120, height: 740 });
|
||||
const dialog = await openCompletionSettings(page);
|
||||
const matchCase = dialog.getByRole("checkbox", { name: "Match case:", exact: true });
|
||||
const choices = dialog.getByRole("radiogroup", { name: "Match case:", exact: true });
|
||||
const first = choices.getByRole("radio", { name: "First letter only", exact: true });
|
||||
const all = choices.getByRole("radio", { name: "All letters", exact: true });
|
||||
await expect(first).toBeChecked();
|
||||
await expect(all).not.toBeChecked();
|
||||
const matchBox = (await matchCase.boundingBox())!;
|
||||
const firstBox = (await first.boundingBox())!;
|
||||
const allBox = (await all.boundingBox())!;
|
||||
expect(Math.abs(matchBox.y - firstBox.y)).toBeLessThan(1);
|
||||
expect(Math.abs(firstBox.y - allBox.y)).toBeLessThan(1);
|
||||
expect(firstBox.x).toBeGreaterThan(matchBox.x + matchBox.width);
|
||||
expect(allBox.x).toBeGreaterThan(firstBox.x + firstBox.width);
|
||||
|
||||
for (const width of [580, 520]) {
|
||||
await page.setViewportSize({ width, height: 740 });
|
||||
await expect(matchCase).toBeInViewport({ ratio: 1 });
|
||||
await expect(first).toBeInViewport({ ratio: 1 });
|
||||
await expect(all).toBeInViewport({ ratio: 1 });
|
||||
await expect(dialog.getByText("All letters", { exact: true })).toBeInViewport({ ratio: 1 });
|
||||
}
|
||||
});
|
||||
|
||||
test("Code Completion preserves case and popup delay preferences across Apply and Cancel", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const dialog = await openCompletionSettings(page);
|
||||
const matchCase = dialog.getByRole("checkbox", { name: "Match case:", exact: true });
|
||||
const first = dialog.getByRole("radio", { name: "First letter only", exact: true });
|
||||
const all = dialog.getByRole("radio", { name: "All letters", exact: true });
|
||||
await matchCase.uncheck();
|
||||
await expect(first).toBeDisabled();
|
||||
await expect(all).toBeDisabled();
|
||||
await expect(first).toBeChecked();
|
||||
await matchCase.check();
|
||||
await first.press("ArrowRight");
|
||||
await expect(all).toBeChecked();
|
||||
|
||||
const docs = dialog.getByRole("textbox", { name: "Show the documentation popup in", exact: true });
|
||||
const params = dialog.getByRole("textbox", { name: "Show the parameter info popup in", exact: true });
|
||||
await dialog.getByRole("checkbox", { name: "Show the documentation popup in", exact: true }).check();
|
||||
await dialog.getByRole("checkbox", { name: "Show the parameter info popup in", exact: true }).check();
|
||||
await docs.fill("750");
|
||||
await params.fill("1250");
|
||||
const apply = dialog.getByRole("button", { name: "Apply", exact: true });
|
||||
const cancel = dialog.getByRole("button", { name: "Cancel", exact: true });
|
||||
await apply.click();
|
||||
await expect(apply).toBeDisabled();
|
||||
await cancel.click();
|
||||
|
||||
await openCompletionSettings(page);
|
||||
await expect(all).toBeChecked();
|
||||
await expect(docs).toHaveValue("750");
|
||||
await expect(params).toHaveValue("1250");
|
||||
await matchCase.uncheck();
|
||||
await expect(all).toBeDisabled();
|
||||
await expect(all).toBeChecked();
|
||||
await cancel.click();
|
||||
await openCompletionSettings(page);
|
||||
await expect(matchCase).toBeChecked();
|
||||
await expect(all).toBeChecked();
|
||||
});
|
||||
@@ -1,71 +0,0 @@
|
||||
import { expect, openFromTree, test } from "./fixtures";
|
||||
|
||||
test("code folding controls stay grouped in narrow settings", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Code Folding");
|
||||
await dialog.getByRole("treeitem", { name: "Code Folding", exact: true }).click();
|
||||
|
||||
const label = "Show code folding outline";
|
||||
const outline = dialog.getByRole("checkbox", { name: label, exact: true });
|
||||
const visibility = dialog.getByRole("button", { name: label, exact: true });
|
||||
const defaults = dialog.getByRole("region", { name: "Fold by default:", exact: true });
|
||||
await expect(visibility).toHaveText("On hover");
|
||||
const wideOutline = (await outline.boundingBox())!;
|
||||
expect((await visibility.boundingBox())!.x).toBeGreaterThan(wideOutline.x + wideOutline.width);
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
await expect(visibility).toBeInViewport({ ratio: 0.98 });
|
||||
const rows = await Promise.all(
|
||||
["File header", "Imports", "Documentation comments"].map((name) =>
|
||||
defaults.getByRole("checkbox", { name, exact: true }).boundingBox(),
|
||||
),
|
||||
);
|
||||
expect(rows[0]!.x).toBe(rows[2]!.x);
|
||||
expect(rows[0]!.y).toBeLessThan(rows[1]!.y);
|
||||
expect(rows[1]!.y).toBeLessThan(rows[2]!.y);
|
||||
|
||||
await outline.uncheck();
|
||||
await expect(dialog.getByRole("textbox", { name: label, exact: true })).toBeDisabled();
|
||||
await expect(defaults.getByRole("checkbox", { name: "Imports", exact: true })).toBeEnabled();
|
||||
});
|
||||
|
||||
test("folding visibility applies to an already open editor and keeps folded arrows visible", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const editor = await openFromTree(page, "App.tsx");
|
||||
const content = editor.locator(".cm-content");
|
||||
await content.click();
|
||||
await page.keyboard.press("Meta+a");
|
||||
await page.keyboard.insertText("export function sum() {\n return 1 + 2;\n}\n");
|
||||
const arrow = editor.locator(".cm-foldGutter .cm-openidea-foldOpen").first();
|
||||
await expect(arrow).toHaveCSS("opacity", "0");
|
||||
|
||||
const openSettings = async () => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Code Folding");
|
||||
await dialog.getByRole("treeitem", { name: "Code Folding", exact: true }).click();
|
||||
return dialog;
|
||||
};
|
||||
const label = "Show code folding outline";
|
||||
const settings = await openSettings();
|
||||
await settings.getByRole("button", { name: label, exact: true }).click();
|
||||
await page.getByRole("option", { name: "Always", exact: true }).click();
|
||||
await settings.getByRole("button", { name: "OK", exact: true }).click();
|
||||
await content.hover();
|
||||
await expect(arrow).toHaveCSS("opacity", "1");
|
||||
|
||||
const reopened = await openSettings();
|
||||
const control = reopened.getByRole("button", { name: label, exact: true });
|
||||
await expect(control).toHaveText("Always");
|
||||
await control.click();
|
||||
await page.getByRole("option", { name: "On hover", exact: true }).click();
|
||||
await reopened.getByRole("button", { name: "OK", exact: true }).click();
|
||||
await content.hover();
|
||||
await expect(arrow).toHaveCSS("opacity", "0");
|
||||
await arrow.click();
|
||||
await content.hover();
|
||||
await expect(editor.locator(".cm-foldGutter .cm-openidea-foldClosed").first()).toHaveCSS("opacity", "1");
|
||||
await expect(editor.locator(".cm-foldPlaceholder").first()).toBeVisible();
|
||||
});
|
||||
@@ -60,21 +60,7 @@ test("completion lists the server's items and inserts the chosen one", async ({
|
||||
await editor.locator(".cm-line", { hasText: "return order.toDto()" }).click();
|
||||
await page.keyboard.press("End");
|
||||
await page.keyboard.press("Enter");
|
||||
await page.keyboard.type("order");
|
||||
const firstPlacement = await page.evaluateHandle(() => {
|
||||
const sample: { labelX?: number } = {};
|
||||
const observer = new MutationObserver(() => {
|
||||
const label = document.querySelector(
|
||||
":is(.cm-tooltip-above, .cm-tooltip-below).cm-lsp-completion .cm-completionLabel",
|
||||
);
|
||||
if (!label) return;
|
||||
sample.labelX = label.getBoundingClientRect().left;
|
||||
observer.disconnect();
|
||||
});
|
||||
observer.observe(document.body, { subtree: true, attributes: true, attributeFilter: ["class"] });
|
||||
return sample;
|
||||
});
|
||||
await page.keyboard.type(".");
|
||||
await page.keyboard.type("order.");
|
||||
await page.keyboard.press("Control+Space");
|
||||
const popup = page.locator(".cm-tooltip-autocomplete");
|
||||
await expect(popup.getByText("total", { exact: true })).toBeVisible();
|
||||
@@ -97,8 +83,6 @@ test("completion lists the server's items and inserts the chosen one", async ({
|
||||
});
|
||||
const label = await method.locator(".cm-completionLabel").boundingBox();
|
||||
// Subpixel rounding differs per platform/font; a mis-set inset is a whole icon column off.
|
||||
const firstLabelX = await firstPlacement.evaluate((sample) => sample.labelX!);
|
||||
expect(Math.abs(firstLabelX - wordStart)).toBeLessThanOrEqual(2);
|
||||
expect(Math.abs(label!.x - wordStart)).toBeLessThanOrEqual(2);
|
||||
const zoomedSize = await editor.locator(".cm-content").evaluate(async (content) => {
|
||||
const viewModule = "/node_modules/.vite/deps/@codemirror_view.js";
|
||||
|
||||
@@ -1,72 +0,0 @@
|
||||
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);
|
||||
});
|
||||
@@ -2,8 +2,7 @@ import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
const amountName = "regionalSettlementAmountFromExternalProcessorBeforeRounding";
|
||||
const routingName = "settlementRoutingReferenceForCrossBorderReconciliation";
|
||||
const routingText = "APR-2026 / eu-west / batch-701 / settlement complete";
|
||||
const routingValue = "'" + routingText + "'";
|
||||
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 });
|
||||
@@ -47,7 +46,7 @@ test("keeps values and their full-value action readable in a narrow debugger", a
|
||||
await expect(show).toBeInViewport({ ratio: 1 });
|
||||
await show.click();
|
||||
const dialog = page.getByRole("dialog", { name: `Value of ${routingName}` });
|
||||
await expect(dialog.getByText(routingText, { exact: true })).toBeVisible();
|
||||
await expect(dialog.getByText(routingValue, { exact: true })).toBeVisible();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(dialog).toBeHidden();
|
||||
|
||||
|
||||
@@ -1,66 +0,0 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("long diagnostics and quick fixes wrap within a narrow editor hover", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 520, height: 580 });
|
||||
const path = "/dev/acme-api/Settlement.ts";
|
||||
const identifier = "QuarterlyCrossBorderSettlementProjection".repeat(4);
|
||||
const message = `Cannot resolve ${identifier}.\nCheck the settlement calculation.`;
|
||||
const title = `Replace with ${identifier}Result`;
|
||||
const range = { start: { line: 0, col: 0 }, end: { line: 0, col: 7 } };
|
||||
await page.evaluate(async (path) => {
|
||||
const backend = "/src/editor/core/backend.ts";
|
||||
(await import(/* @vite-ignore */ backend)).docBackend().files.set(path, "pending();\n");
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile(path);
|
||||
}, path);
|
||||
await expect(page.locator(".cm-content")).toContainText("pending()");
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ path, message, title, range }) => {
|
||||
window.__ipc.handlers.lsp_hover = () => null;
|
||||
window.__ipc.handlers.lsp_code_actions = () => [
|
||||
{
|
||||
title,
|
||||
kind: "quickfix",
|
||||
isPreferred: true,
|
||||
disabledReason: null,
|
||||
edit: {
|
||||
files: [{ kind: "edit", path, edits: [{ range, new_text: "settled" }] }],
|
||||
},
|
||||
command: null,
|
||||
data: null,
|
||||
server: 1,
|
||||
},
|
||||
];
|
||||
const diagnostic = "/src/editor/lsp/diagnostics.ts";
|
||||
(await import(/* @vite-ignore */ diagnostic)).setFileDiagnostics(path, "settlement-lint", [
|
||||
{ severity: "error", message, range, source: "settlement-lint", code: "missing-model" },
|
||||
{ severity: "hint", message: "Review the reported total.", range, source: "settlement-lint", code: "review" },
|
||||
]);
|
||||
},
|
||||
{ path, message, title, range },
|
||||
);
|
||||
|
||||
await page.locator(".cm-content .cm-lintRange-error").hover();
|
||||
const hover = page.locator(".cm-lsp-hover");
|
||||
await expect(hover).toBeVisible();
|
||||
const fix = hover.getByRole("button", { name: new RegExp(`^${title}`) });
|
||||
await expect(fix).toBeVisible();
|
||||
expect(await hover.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
const messageText = hover.locator(".cm-lsp-diag-message").first();
|
||||
await expect(messageText).toHaveText(message);
|
||||
await expect(messageText).toHaveCSS("font-size", "13px");
|
||||
const shortcut = fix.locator(".cm-lsp-diag-shortcut");
|
||||
await expect(shortcut).toBeVisible();
|
||||
await expect(shortcut).toHaveCSS("font-size", "12px");
|
||||
const more = hover.getByRole("button", { name: "More actions…", exact: true }).first();
|
||||
await expect(more).toBeInViewport({ ratio: 1 });
|
||||
const outer = (await hover.boundingBox())!;
|
||||
const action = (await fix.boundingBox())!;
|
||||
const editor = (await page.locator(".cm-editor").boundingBox())!;
|
||||
expect(outer.x + outer.width).toBeLessThanOrEqual(editor.x + editor.width + 1);
|
||||
expect(action.x + action.width).toBeLessThanOrEqual(outer.x + outer.width);
|
||||
await more.click();
|
||||
const intentions = page.getByRole("dialog", { name: "Intentions", exact: true });
|
||||
await expect(intentions.getByRole("option", { name: title })).toBeVisible();
|
||||
});
|
||||
@@ -406,48 +406,6 @@ 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");
|
||||
@@ -666,24 +624,12 @@ 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);
|
||||
|
||||
@@ -1,87 +0,0 @@
|
||||
import type { Page } from "@playwright/test";
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
async function openGeneral(page: Page) {
|
||||
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("File patterns");
|
||||
await settings.getByRole("treeitem", { name: "General", exact: true }).click();
|
||||
await search.clear();
|
||||
return settings;
|
||||
}
|
||||
|
||||
test("Editor General fits the soft-wrap pattern field and stacks the scrolling choices", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 1120, height: 850 });
|
||||
const settings = await openGeneral(page);
|
||||
const softWraps = settings.getByRole("region", { name: "Soft Wraps", exact: true });
|
||||
const wrap = softWraps.getByRole("checkbox", { name: "Soft-wrap files", exact: true });
|
||||
const patterns = softWraps.getByRole("textbox", { name: "File patterns" });
|
||||
const scrolling = settings.getByRole("region", { name: "Scrolling", exact: true });
|
||||
const virtualSpace = settings.getByRole("region", { name: "Virtual Space", exact: true });
|
||||
const caretPrompt = scrolling.getByText("When caret is moved", { exact: true });
|
||||
const center = scrolling.getByRole("radio", { name: /keep caret line centered/ });
|
||||
const minimize = scrolling.getByRole("radio", { name: /minimize editor scrolling/ });
|
||||
|
||||
await expect(patterns).toBeVisible();
|
||||
const toggle = (await wrap.boundingBox())!;
|
||||
const field = (await patterns.boundingBox())!;
|
||||
expect(toggle.y).toBeGreaterThan(field.y);
|
||||
expect(toggle.y + toggle.height).toBeLessThan(field.y + field.height);
|
||||
expect(field.x).toBeGreaterThan(toggle.x + toggle.width);
|
||||
expect(await patterns.getAttribute("aria-describedby")).toBeTruthy();
|
||||
|
||||
for (const width of [1120, 520]) {
|
||||
await page.setViewportSize({ width, height: 850 });
|
||||
await patterns.scrollIntoViewIfNeeded();
|
||||
await expect(patterns).toBeInViewport({ ratio: 0.99 });
|
||||
const fieldBox = (await patterns.boundingBox())!;
|
||||
const indent = softWraps.getByRole("checkbox", { name: "Use original line's indent for wrapped parts" });
|
||||
expect((await indent.boundingBox())!.y).toBeGreaterThan(fieldBox.y + fieldBox.height);
|
||||
expect(await scrolling.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
expect((await scrolling.boundingBox())!.y).toBeGreaterThan((await virtualSpace.boundingBox())!.y);
|
||||
const first = (await center.boundingBox())!;
|
||||
const second = (await minimize.boundingBox())!;
|
||||
expect(first.x).toBeGreaterThan((await caretPrompt.boundingBox())!.x);
|
||||
expect(second.y).toBeGreaterThan(first.y + first.height);
|
||||
expect(Math.abs(first.x - second.x)).toBeLessThan(1);
|
||||
}
|
||||
});
|
||||
|
||||
test("Editor General keeps wheel and wrap dependencies and saves the selected values", async ({ workbench: page }) => {
|
||||
const settings = await openGeneral(page);
|
||||
const zoom = settings.getByRole("checkbox", { name: "Change font size with Ctrl/Command+Mouse Wheel" });
|
||||
const active = settings.getByRole("radio", { name: "Active editor", exact: true });
|
||||
const all = settings.getByRole("radio", { name: "All editors", exact: true });
|
||||
const wrap = settings.getByRole("checkbox", { name: "Soft-wrap files", exact: true });
|
||||
const patterns = settings.getByRole("textbox", { name: "File patterns", exact: true });
|
||||
const indent = settings.getByRole("checkbox", { name: "Use original line's indent for wrapped parts" });
|
||||
const apply = settings.getByRole("button", { name: "Apply", exact: true });
|
||||
const cancel = settings.getByRole("button", { name: "Cancel", exact: true });
|
||||
|
||||
await zoom.uncheck();
|
||||
await expect(active).toBeDisabled();
|
||||
await expect(all).toBeDisabled();
|
||||
await zoom.check();
|
||||
await expect(active).toBeChecked();
|
||||
await active.focus();
|
||||
await page.keyboard.press("ArrowDown");
|
||||
await expect(all).toBeChecked();
|
||||
await wrap.uncheck();
|
||||
await expect(patterns).toBeDisabled();
|
||||
await expect(indent).toBeDisabled();
|
||||
await wrap.check();
|
||||
await expect(indent).toBeEnabled();
|
||||
await patterns.fill("*.md; *.notes");
|
||||
await apply.click();
|
||||
await expect(apply).toBeDisabled();
|
||||
await cancel.click();
|
||||
|
||||
await openGeneral(page);
|
||||
await expect(zoom).toBeChecked();
|
||||
await expect(all).toBeChecked();
|
||||
await expect(wrap).toBeChecked();
|
||||
await expect(patterns).toHaveValue("*.md; *.notes");
|
||||
});
|
||||
@@ -1,88 +0,0 @@
|
||||
import type { Page } from "@playwright/test";
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
async function openFileColors(page: Page) {
|
||||
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("Use in project view");
|
||||
await settings.getByRole("treeitem", { name: "File Colors", exact: true }).click();
|
||||
await search.clear();
|
||||
return settings;
|
||||
}
|
||||
|
||||
test("File Colors fits its switches and keeps the toolbar and table headings in view", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1120, height: 760 });
|
||||
const settings = await openFileColors(page);
|
||||
const table = settings.getByRole("table", { name: "File colors", exact: true });
|
||||
const scope = table.getByRole("columnheader", { name: "Scope", exact: true });
|
||||
const color = table.getByRole("columnheader", { name: "Color", exact: true });
|
||||
const toolbar = settings.getByRole("toolbar", { name: "File colors actions", exact: true });
|
||||
const master = settings.getByRole("checkbox", { name: "Enable file colors", exact: true });
|
||||
const project = settings.getByRole("checkbox", { name: "Use in project view", exact: true });
|
||||
const hex = settings.getByRole("textbox", { name: "Custom colour hex", exact: true });
|
||||
|
||||
await expect(scope).toBeVisible();
|
||||
expect(Math.abs((await master.boundingBox())!.y - (await project.boundingBox())!.y)).toBeLessThan(1);
|
||||
|
||||
for (const width of [1120, 520]) {
|
||||
await page.setViewportSize({ width, height: 760 });
|
||||
await expect(project).toBeInViewport({ ratio: 1 });
|
||||
await expect(color).toBeInViewport({ ratio: 1 });
|
||||
await expect(hex).toBeInViewport({ ratio: 1 });
|
||||
expect((await hex.boundingBox())!.width).toBeGreaterThan(70);
|
||||
expect((await color.boundingBox())!.width).toBeGreaterThan(80);
|
||||
const cell = table.getByRole("cell", { name: "Green", exact: true });
|
||||
expect(Math.abs((await color.boundingBox())!.x - (await cell.boundingBox())!.x)).toBeLessThan(1);
|
||||
}
|
||||
|
||||
const add = toolbar.getByRole("button", { name: "Add", exact: true });
|
||||
for (let i = 0; i < 10; i++) await add.click();
|
||||
const last = table.getByRole("row").last();
|
||||
await expect(last.getByRole("button")).toHaveAttribute("aria-pressed", "true");
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(scope).toBeInViewport({ ratio: 1 });
|
||||
await expect(toolbar).toBeInViewport({ ratio: 1 });
|
||||
});
|
||||
|
||||
test("File Colors preserves ordered rules and placement settings across Apply and Cancel", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const settings = await openFileColors(page);
|
||||
const table = settings.getByRole("table", { name: "File colors", exact: true });
|
||||
const tests = table.getByRole("button", { name: "Tests", exact: true });
|
||||
const firstRule = table.getByRole("row").nth(1);
|
||||
const toolbar = settings.getByRole("toolbar", { name: "File colors actions", exact: true });
|
||||
const tabs = settings.getByRole("checkbox", { name: "Use in editor tabs", exact: true });
|
||||
const master = settings.getByRole("checkbox", { name: "Enable file colors", exact: true });
|
||||
const apply = settings.getByRole("button", { name: "Apply", exact: true });
|
||||
const cancel = settings.getByRole("button", { name: "Cancel", exact: true });
|
||||
|
||||
await tabs.uncheck();
|
||||
await master.uncheck();
|
||||
await expect(tabs).toBeDisabled();
|
||||
await master.check();
|
||||
await expect(tabs).not.toBeChecked();
|
||||
await expect(tabs).toBeEnabled();
|
||||
await tests.press("Enter");
|
||||
await expect(tests).toHaveAttribute("aria-pressed", "true");
|
||||
await settings.getByRole("textbox", { name: "Custom colour hex", exact: true }).fill("#1258a5");
|
||||
await toolbar.getByRole("button", { name: "Move Up", exact: true }).click();
|
||||
await expect(firstRule.getByRole("button", { name: "Tests", exact: true })).toBeVisible();
|
||||
await expect(firstRule.getByRole("cell", { name: "#1258a5", exact: true })).toBeVisible();
|
||||
await apply.click();
|
||||
await expect(apply).toBeDisabled();
|
||||
await cancel.click();
|
||||
|
||||
await openFileColors(page);
|
||||
await expect(tabs).not.toBeChecked();
|
||||
await expect(firstRule.getByRole("cell", { name: "#1258a5", exact: true })).toBeVisible();
|
||||
const remove = toolbar.getByRole("button", { name: "Remove", exact: true });
|
||||
await remove.click();
|
||||
await remove.click();
|
||||
await expect(table.getByText("No file colors. Click + to add one.", { exact: true })).toBeVisible();
|
||||
await expect(remove).toBeDisabled();
|
||||
await cancel.click();
|
||||
await openFileColors(page);
|
||||
await expect(firstRule.getByRole("cell", { name: "#1258a5", exact: true })).toBeVisible();
|
||||
});
|
||||
@@ -1,67 +0,0 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test.beforeEach(async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
await expect(page.getByRole("dialog", { name: "Settings", exact: true })).toBeVisible();
|
||||
await page.evaluate(async () => {
|
||||
const path = "/src/features/settings/model/staging.ts";
|
||||
(await import(/* @vite-ignore */ path)).selectPage("editor.fileTemplates");
|
||||
});
|
||||
});
|
||||
|
||||
test("file template fields and editors fit in narrow settings", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
const tabs = page.getByRole("tablist", { name: "Template kinds" });
|
||||
const name = page.getByRole("textbox", { name: "Template name" });
|
||||
const extension = page.getByRole("textbox", { name: "Extension" });
|
||||
const style = page.getByRole("button", { name: "File name style" });
|
||||
const body = page.getByRole("textbox", { name: "Template body", exact: true });
|
||||
|
||||
await expect(body).toBeInViewport({ ratio: 0.98 });
|
||||
expect((await body.boundingBox())!.width).toBeGreaterThan(150);
|
||||
await expect(extension).toBeInViewport({ ratio: 0.98 });
|
||||
await expect(style).toBeInViewport({ ratio: 0.98 });
|
||||
expect((await extension.boundingBox())!.y).toBeGreaterThan((await name.boundingBox())!.y);
|
||||
expect((await style.boundingBox())!.y).toBeGreaterThan((await extension.boundingBox())!.y);
|
||||
await style.click();
|
||||
await expect(page.getByRole("option", { name: "PascalCase" })).toBeVisible();
|
||||
await page.keyboard.press("Escape");
|
||||
|
||||
for (const [tab, editorName] of [
|
||||
["Includes", "Include body"],
|
||||
["Code", "Code template body"],
|
||||
]) {
|
||||
await tabs.getByRole("tab", { name: tab, exact: true }).click();
|
||||
await expect(page.getByRole("textbox", { name: editorName, exact: true })).toBeInViewport({ ratio: 0.98 });
|
||||
}
|
||||
});
|
||||
|
||||
test("file template tabs share a remembered, keyboard-adjustable divider", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1100, height: 760 });
|
||||
const tabs = page.getByRole("tablist", { name: "Template kinds" });
|
||||
const name = page.getByRole("textbox", { name: "Template name" });
|
||||
const extension = page.getByRole("textbox", { name: "Extension" });
|
||||
const divider = page.getByRole("separator", { name: "Resize file template panes" });
|
||||
const width = async (listName: string) =>
|
||||
(await page.getByRole("listbox", { name: listName, exact: true }).boundingBox())!.width;
|
||||
|
||||
await expect(divider).toBeVisible();
|
||||
expect((await extension.boundingBox())!.y).toBe((await name.boundingBox())!.y);
|
||||
const initial = await width("File templates");
|
||||
await divider.press("ArrowRight");
|
||||
await expect.poll(() => width("File templates")).toBeGreaterThan(initial + 10);
|
||||
const resized = await width("File templates");
|
||||
|
||||
await tabs.getByRole("tab", { name: "Files", exact: true }).press("ArrowRight");
|
||||
await expect(tabs.getByRole("tab", { name: "Includes", exact: true })).toBeFocused();
|
||||
await expect.poll(() => width("Includes")).toBeCloseTo(resized, 0);
|
||||
await page.getByRole("button", { name: "Add Include" }).click();
|
||||
const include = page.getByRole("textbox", { name: "Include body" });
|
||||
await include.fill("// Shared header");
|
||||
|
||||
await tabs.getByRole("tab", { name: "Code", exact: true }).click();
|
||||
await expect.poll(() => width("Code templates")).toBeCloseTo(resized, 0);
|
||||
await tabs.getByRole("tab", { name: "Includes", exact: true }).click();
|
||||
await page.getByRole("option", { name: "New Include", exact: true }).click();
|
||||
await expect(include).toHaveValue("// Shared header");
|
||||
});
|
||||
@@ -1,75 +0,0 @@
|
||||
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();
|
||||
});
|
||||
@@ -1,93 +0,0 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test.beforeEach(async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Inlay Hints");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
});
|
||||
|
||||
test("inlay hint categories and the preview fit at both settings widths", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const categories = dialog.getByRole("listbox", { name: "Inlay hint categories" });
|
||||
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
|
||||
await expect(preview).toBeVisible();
|
||||
await expect(preview.getByText(": f64", { exact: true })).toBeVisible();
|
||||
|
||||
await page.setViewportSize({ width: 1100, height: 760 });
|
||||
const wideList = (await categories.boundingBox())!;
|
||||
const widePreview = (await preview.boundingBox())!;
|
||||
expect(widePreview.x).toBeGreaterThan(wideList.x + wideList.width);
|
||||
expect(widePreview.y).toBeLessThan(wideList.y + wideList.height);
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
await categories.press("End");
|
||||
await expect(categories.getByRole("option", { name: /^Other hints/ })).toHaveAttribute("aria-selected", "true");
|
||||
await expect(preview.getByText("= 300", { exact: true })).toBeVisible();
|
||||
const narrowList = (await categories.boundingBox())!;
|
||||
const narrowPreview = (await preview.boundingBox())!;
|
||||
expect(narrowPreview.y).toBeGreaterThan(narrowList.y + narrowList.height);
|
||||
await expect(preview).toBeInViewport({ ratio: 0.98 });
|
||||
expect(await preview.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
});
|
||||
|
||||
test("the hint preview follows staged settings and saves the selected category", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const search = dialog.getByRole("textbox", { name: "Search settings" });
|
||||
const categories = dialog.getByRole("listbox", { name: "Inlay hint categories" });
|
||||
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
|
||||
const master = dialog.getByRole("checkbox", { name: "Show inlay hints", exact: true });
|
||||
const parameters = dialog.getByRole("checkbox", { name: "Parameter names", exact: true });
|
||||
const parameterHint = preview.getByText("width:", { exact: true });
|
||||
|
||||
await search.fill("Parameter names");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
await expect(categories.getByRole("option", { name: "Parameter names", exact: true })).toHaveAttribute(
|
||||
"aria-selected",
|
||||
"true",
|
||||
);
|
||||
await expect(parameterHint).toBeVisible();
|
||||
await master.uncheck();
|
||||
await expect(parameters).toBeDisabled();
|
||||
await expect(parameterHint).toHaveCount(0);
|
||||
await expect(dialog.getByRole("checkbox", { name: "Show Code Vision", exact: true })).toBeEnabled();
|
||||
await master.check();
|
||||
await expect(parameterHint).toBeVisible();
|
||||
|
||||
await parameters.uncheck();
|
||||
await expect(parameterHint).toHaveCount(0);
|
||||
await categories.press("Home");
|
||||
await expect(preview.getByText(": f64", { exact: true })).toBeVisible();
|
||||
await dialog.getByRole("button", { name: "Apply", exact: true }).click();
|
||||
await expect(dialog.getByRole("button", { name: "Apply", exact: true })).toBeDisabled();
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
|
||||
await page.keyboard.press("Meta+,");
|
||||
await search.fill("Parameter names");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
await expect(parameters).not.toBeChecked();
|
||||
await expect(parameterHint).toHaveCount(0);
|
||||
});
|
||||
|
||||
test("the hint preview respects the sample language's staged preference", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(() => {
|
||||
window.__ipc.handlers.languages = () => [
|
||||
{ id: "go", name: "Go" },
|
||||
{ id: "rust", name: "Rust" },
|
||||
];
|
||||
});
|
||||
await page.keyboard.press("Meta+,");
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Inlay Hints");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
|
||||
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
|
||||
const typeHint = preview.getByText(": f64", { exact: true });
|
||||
await expect(typeHint).toBeVisible();
|
||||
await dialog.getByRole("checkbox", { name: "Rust", exact: true }).uncheck();
|
||||
await expect(typeHint).toHaveCount(0);
|
||||
await dialog.getByRole("listbox", { name: "Inlay hint categories" }).press("End");
|
||||
await expect(preview.getByText("= 300", { exact: true })).toBeVisible();
|
||||
});
|
||||
@@ -133,20 +133,3 @@ test("rectangular drag remains configurable after removal and saves a middle mou
|
||||
await expect(row).toContainText("Middle Click");
|
||||
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
});
|
||||
|
||||
test("the action search also finds actions by typed shortcut text", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await settings.getByRole("treeitem", { name: "Keymap", exact: true }).click();
|
||||
const search = settings.getByRole("textbox", { name: "Search actions", exact: true });
|
||||
const actions = settings.getByRole("tree", { name: "Actions" });
|
||||
const goToFile = actions.getByRole("treeitem", { name: /Go to File/ });
|
||||
for (const query of ["cmd+shift+o", "Shift+Meta+O", "⇧⌘O"]) {
|
||||
await search.fill(query);
|
||||
await expect(goToFile).toBeVisible();
|
||||
await expect(actions.getByRole("treeitem", { name: /Recent Files/ })).toHaveCount(0);
|
||||
}
|
||||
const shots = process.env.OPENIDEA_E2E_SHOTS;
|
||||
if (shots) await settings.screenshot({ path: `${shots}/after.png`, animations: "disabled" });
|
||||
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
});
|
||||
@@ -1,138 +0,0 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("the floating navigation list stays beside the visible segment and scrolls to keyboard selection", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 600, height: 560 });
|
||||
const folder = "billing";
|
||||
const parent =
|
||||
"/dev/acme-api/quarterly-settlement-and-reconciliation/merchant-accounts-with-exchange-rate-adjustments";
|
||||
const directory = `${parent}/${folder}`;
|
||||
const filename = "SettlementSummary.ts";
|
||||
const path = `${directory}/${filename}`;
|
||||
const long = "QuarterlyReconciliationForPendingSettlementAndCrossBorderMerchantAdjustments.ts";
|
||||
const last = "YearEndTotals.ts";
|
||||
await page.evaluate(async (path) => {
|
||||
const backend = "/src/editor/core/backend.ts";
|
||||
(await import(/* @vite-ignore */ backend)).docBackend().files.set(path, "export const pending = 1;\n");
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile(path);
|
||||
}, path);
|
||||
await expect(page.locator(".cm-content")).toContainText("pending");
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ directory, filename, long, last }) => {
|
||||
window.__ipc.handlers.fs_read_dir = ({ path }) =>
|
||||
path === directory
|
||||
? ["archive", long, ...Array.from({ length: 24 }, (_, i) => `Report-${i + 1}.ts`), filename, last].map(
|
||||
(name) => ({
|
||||
name,
|
||||
path: `${directory}/${name}`,
|
||||
kind: name === "archive" ? "dir" : "file",
|
||||
size: name === "archive" ? 0 : 1,
|
||||
}),
|
||||
)
|
||||
: [];
|
||||
const actions = "/src/platform/actions.ts";
|
||||
await (await import(/* @vite-ignore */ actions)).executeAction("navigate.navigationBar");
|
||||
},
|
||||
{ directory, filename, long, last },
|
||||
);
|
||||
const bar = page.getByRole("toolbar", { name: "Navigation bar" });
|
||||
await expect(bar).toBeVisible();
|
||||
await page.keyboard.press("ArrowLeft");
|
||||
const segment = bar.getByRole("button", { name: folder, exact: true });
|
||||
await expect(segment).toHaveAttribute("aria-current", "location");
|
||||
const barBounds = (await bar.boundingBox())!;
|
||||
await page.keyboard.press("ArrowDown");
|
||||
const list = page.getByRole("listbox", { name: "Children" });
|
||||
await expect(list).toBeVisible();
|
||||
await expect(list.getByRole("option", { name: filename, exact: true })).toHaveAttribute("aria-selected", "true");
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const bounds = (await list.boundingBox())!;
|
||||
return bounds.x >= 5 && bounds.x + bounds.width <= 595;
|
||||
})
|
||||
.toBe(true);
|
||||
expect((await list.boundingBox())!.y).toBeGreaterThanOrEqual(barBounds.y + barBounds.height - 4);
|
||||
expect((await bar.boundingBox())!.height).toBeCloseTo(barBounds.height);
|
||||
|
||||
await page.keyboard.press("Home");
|
||||
const folderRow = list.getByRole("option", { name: "archive" });
|
||||
await expect(folderRow).toHaveAttribute("aria-selected", "true");
|
||||
await expect(folderRow).toBeInViewport({ ratio: 1 });
|
||||
await expect(list.getByRole("option", { name: long, exact: true }).getByTitle(long)).toBeVisible();
|
||||
expect(await list.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await page.keyboard.press("End");
|
||||
const lastRow = list.getByRole("option", { name: last, exact: true });
|
||||
await expect(lastRow).toHaveAttribute("aria-selected", "true");
|
||||
await expect(lastRow).toBeInViewport({ ratio: 1 });
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(list).toBeHidden();
|
||||
await expect(bar).toBeFocused();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(bar).toBeHidden();
|
||||
});
|
||||
|
||||
for (const position of ["top", "statusBar"] as const) {
|
||||
test(`the ${position} navigation list opens toward the editor and keeps folder navigation`, async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const directory = "/dev/acme-api/src";
|
||||
const path = `${directory}/Overview.ts`;
|
||||
await page.evaluate(async (path) => {
|
||||
const backend = "/src/editor/core/backend.ts";
|
||||
(await import(/* @vite-ignore */ backend)).docBackend().files.set(path, "export const overview = 1;\n");
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile(path);
|
||||
}, path);
|
||||
await expect(page.locator(".cm-content")).toContainText("overview");
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ directory, position }) => {
|
||||
const archive = `${directory}/archive`;
|
||||
window.__ipc.handlers.fs_read_dir = ({ path }) =>
|
||||
path === directory
|
||||
? [
|
||||
{ path: archive, name: "archive", kind: "dir", size: 0 },
|
||||
{ path: `${directory}/Overview.ts`, name: "Overview.ts", kind: "file", size: 1 },
|
||||
]
|
||||
: path === archive
|
||||
? [{ path: `${archive}/Previous.ts`, name: "Previous.ts", kind: "file", size: 1 }]
|
||||
: [];
|
||||
const source = await (await fetch("/src/workbench/Workbench.tsx")).text();
|
||||
const project = source.match(/["'](\/src\/platform\/project\.ts(?:\?[^"']+)?)["']/)?.[1];
|
||||
if (!project) throw new Error("Missing project store");
|
||||
const { useProject } = await import(/* @vite-ignore */ project);
|
||||
const settings = useProject.getState().settings;
|
||||
useProject.setState({
|
||||
settings: { ...settings, appearance: { ...settings?.appearance, navigationBar: position } },
|
||||
});
|
||||
},
|
||||
{ directory, position },
|
||||
);
|
||||
const anchor = page
|
||||
.getByRole("navigation", { name: "Breadcrumbs" })
|
||||
.getByRole("button", { name: "src", exact: true });
|
||||
await anchor.click();
|
||||
const list = page.getByRole("listbox", { name: "src", exact: true });
|
||||
const archive = list.getByRole("option", { name: "archive" });
|
||||
await expect(archive).toHaveAttribute("aria-selected", "true");
|
||||
await expect(list).toBeFocused();
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const bounds = (await anchor.boundingBox())!;
|
||||
const popup = (await list.boundingBox())!;
|
||||
return position === "top" ? popup.y >= bounds.y + bounds.height : popup.y + popup.height <= bounds.y;
|
||||
})
|
||||
.toBe(true);
|
||||
await page.keyboard.press("ArrowRight");
|
||||
const nested = page.getByRole("listbox", { name: "archive" });
|
||||
await expect(nested.getByRole("option", { name: "Previous.ts" })).toHaveAttribute("aria-selected", "true");
|
||||
await page.keyboard.press("ArrowLeft");
|
||||
await expect(archive).toHaveAttribute("aria-selected", "true");
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(list).toBeHidden();
|
||||
await expect(anchor).toBeFocused();
|
||||
});
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test.beforeEach(async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Notifications");
|
||||
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
|
||||
});
|
||||
|
||||
test("notification group controls stay inside narrow settings", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
const groups = page.getByRole("region", { name: "Groups", exact: true });
|
||||
const popup = groups.getByRole("button", { name: "System Messages popup type" });
|
||||
await expect(popup).toBeInViewport({ ratio: 0.98 });
|
||||
expect(await groups.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
|
||||
const list = groups.getByRole("listbox", { name: "Notification groups" });
|
||||
const controls = groups.getByRole("region", { name: "System Messages", exact: true });
|
||||
const listBounds = (await list.boundingBox())!;
|
||||
expect((await controls.boundingBox())!.y).toBeGreaterThanOrEqual(listBounds.y + listBounds.height);
|
||||
await popup.click();
|
||||
await expect(page.getByRole("option", { name: "Sticky balloon", exact: true })).toBeInViewport();
|
||||
await page.keyboard.press("Escape");
|
||||
|
||||
await list.press("End");
|
||||
const lastGroup = list.getByRole("option", { name: "Distraction Free Mode", exact: true });
|
||||
await expect(lastGroup).toHaveAttribute("aria-selected", "true");
|
||||
await expect(lastGroup).toBeInViewport({ ratio: 0.98 });
|
||||
await list.press("Home");
|
||||
|
||||
await page.setViewportSize({ width: 1100, height: 760 });
|
||||
const wideList = (await list.boundingBox())!;
|
||||
const wideControls = (await controls.boundingBox())!;
|
||||
expect(wideControls.x).toBeGreaterThan(wideList.x + wideList.width);
|
||||
expect(wideControls.y).toBeLessThan(wideList.y + wideList.height);
|
||||
});
|
||||
|
||||
test("notification groups follow settings search and keep edits per group", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const search = dialog.getByRole("textbox", { name: "Search settings" });
|
||||
const list = dialog.getByRole("listbox", { name: "Notification groups" });
|
||||
const systemPopup = dialog.getByRole("button", { name: "System Messages popup type" });
|
||||
const versionControlPopup = dialog.getByRole("button", { name: "Version Control popup type" });
|
||||
const versionControlLog = dialog.getByRole("checkbox", { name: "Show Version Control in tool window" });
|
||||
|
||||
await list.press("ArrowDown");
|
||||
await expect(list.getByRole("option", { name: "Language Servers" })).toHaveAttribute("aria-selected", "true");
|
||||
await search.fill("Version Control");
|
||||
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
|
||||
await expect(list.getByRole("option", { name: "Version Control", exact: true })).toHaveAttribute(
|
||||
"aria-selected",
|
||||
"true",
|
||||
);
|
||||
await versionControlPopup.click();
|
||||
await page.getByRole("option", { name: "No popup", exact: true }).click();
|
||||
await versionControlLog.uncheck();
|
||||
|
||||
await list.press("Home");
|
||||
await expect(systemPopup).toHaveText("Balloon");
|
||||
await expect(dialog.getByRole("checkbox", { name: "Show System Messages in tool window" })).toBeChecked();
|
||||
await list.getByRole("option", { name: "Version Control", exact: true }).click();
|
||||
await expect(versionControlPopup).toHaveText("No popup");
|
||||
await expect(versionControlLog).not.toBeChecked();
|
||||
|
||||
await dialog.getByRole("button", { name: "Apply", exact: true }).click();
|
||||
await expect(dialog.getByRole("button", { name: "Apply", exact: true })).toBeDisabled();
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await page.keyboard.press("Meta+,");
|
||||
await search.fill("Version Control");
|
||||
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
|
||||
await expect(versionControlPopup).toHaveText("No popup");
|
||||
await expect(versionControlLog).not.toBeChecked();
|
||||
});
|
||||
@@ -1,80 +0,0 @@
|
||||
import type { Page } from "@playwright/test";
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
async function openPostfixSettings(page: Page) {
|
||||
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("Postfix Completion");
|
||||
await settings.getByRole("treeitem", { name: "Postfix Completion", exact: true }).click();
|
||||
await search.clear();
|
||||
return settings;
|
||||
}
|
||||
|
||||
test("Postfix Completion pairs the template list with a responsive code preview", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1120, height: 760 });
|
||||
const settings = await openPostfixSettings(page);
|
||||
const list = settings.getByRole("list", { name: "Postfix templates", exact: true });
|
||||
const preview = settings.getByRole("region", { name: "Template preview", exact: true });
|
||||
const before = preview.locator("pre").first();
|
||||
const after = preview.locator("pre").last();
|
||||
await expect(before).toHaveText("expr.if");
|
||||
await expect(after).toContainText("if (expr)");
|
||||
const listBounds = (await list.boundingBox())!;
|
||||
const widePreview = (await preview.boundingBox())!;
|
||||
expect(widePreview.x).toBeGreaterThanOrEqual(listBounds.x + listBounds.width);
|
||||
expect(widePreview.y).toBeLessThan(listBounds.y);
|
||||
|
||||
await list.getByRole("button", { name: ".if", exact: true }).press("ArrowDown");
|
||||
const elseTemplate = list.getByRole("button", { name: ".else", exact: true });
|
||||
await expect(elseTemplate).toBeFocused();
|
||||
await expect(elseTemplate).toHaveAttribute("aria-pressed", "true");
|
||||
await expect(before).toHaveText("expr.else");
|
||||
await expect(after).toContainText("if (!expr)");
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
await settings.getByRole("tab", { name: "Python", exact: true }).click();
|
||||
await expect(before).toHaveText("expr.if");
|
||||
await expect(after).toContainText("if expr:");
|
||||
await after.scrollIntoViewIfNeeded();
|
||||
await expect(after).toBeInViewport({ ratio: 0.99 });
|
||||
const narrowList = (await list.boundingBox())!;
|
||||
const narrowPreview = (await preview.boundingBox())!;
|
||||
expect(narrowPreview.y).toBeGreaterThanOrEqual(narrowList.y + narrowList.height);
|
||||
expect(Math.abs(narrowList.x - narrowPreview.x)).toBeLessThan(2);
|
||||
expect(await preview.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
|
||||
await settings.getByRole("tab", { name: "JavaScript / TypeScript", exact: true }).click();
|
||||
await expect(elseTemplate).toHaveAttribute("aria-pressed", "true");
|
||||
await expect(before).toHaveText("expr.else");
|
||||
|
||||
await settings.getByRole("tab", { name: "Java", exact: true }).click();
|
||||
await list.getByRole("button", { name: ".var", exact: true }).click();
|
||||
await expect(preview.getByText("Fallback expansion", { exact: true })).toBeVisible();
|
||||
await expect(after).toContainText("var value = expr;");
|
||||
});
|
||||
|
||||
test("Postfix Completion keeps template selection separate from enabled preferences", async ({ workbench: page }) => {
|
||||
const settings = await openPostfixSettings(page);
|
||||
const master = settings.getByRole("checkbox", { name: "Enable postfix completion", exact: true });
|
||||
const expand = settings.getByRole("checkbox", { name: "Expand templates with Tab", exact: true });
|
||||
const ifEnabled = settings.getByRole("checkbox", { name: "Enable .if", exact: true });
|
||||
const preview = settings.getByRole("region", { name: "Template preview", exact: true });
|
||||
const before = preview.locator("pre").first();
|
||||
await settings.getByRole("button", { name: ".else", exact: true }).click();
|
||||
await expect(ifEnabled).toBeChecked();
|
||||
await ifEnabled.uncheck();
|
||||
await expect(before).toHaveText("expr.if");
|
||||
await master.uncheck();
|
||||
await expect(expand).toBeDisabled();
|
||||
await expect(ifEnabled).toBeDisabled();
|
||||
await settings.getByRole("button", { name: ".else", exact: true }).click();
|
||||
await expect(before).toHaveText("expr.else");
|
||||
await master.check();
|
||||
await expect(ifEnabled).not.toBeChecked();
|
||||
|
||||
await settings.getByRole("button", { name: "OK", exact: true }).click();
|
||||
await openPostfixSettings(page);
|
||||
await expect(ifEnabled).not.toBeChecked();
|
||||
await expect(master).toBeChecked();
|
||||
});
|
||||
@@ -1,56 +0,0 @@
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
const parent = "/dev/imports/From-vendor/QuarterlySettlementReconciliationAndReportingProjects";
|
||||
const project = `${parent}/settlement-api`;
|
||||
|
||||
test("the trust prompt keeps the folder scope and restricted preview visible in a narrow window", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 420, height: 455 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(() => {
|
||||
const h = window.__ipc.handlers;
|
||||
h.project_trust_status = ({ path }) => ({ root: path, trusted: false, decided: false });
|
||||
h.project_trust_set = () => null;
|
||||
h.open_project = ({ path }) => ({ root: path, name: "settlement-api", trusted: false, isGit: false, settings: {} });
|
||||
h.fs_read_dir = () => [];
|
||||
});
|
||||
const open = () =>
|
||||
page.evaluate(async (path) => {
|
||||
const projectModule = "/src/platform/project.ts";
|
||||
const { openProject } = await import(/* @vite-ignore */ projectModule);
|
||||
void openProject(path).catch(() => undefined);
|
||||
}, project);
|
||||
await open();
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Trust and Open Project?" });
|
||||
const restricted = dialog.getByRole("button", { name: "Preview in Restricted Mode" });
|
||||
const folder = dialog.getByRole("checkbox", { name: /Trust projects in/ });
|
||||
const projectAction = dialog.getByRole("button", { name: "Trust Project", exact: true });
|
||||
const folderAction = dialog.getByRole("button", { name: "Trust Folder", exact: true });
|
||||
await expect(restricted).toBeFocused();
|
||||
await expect(projectAction).toBeVisible();
|
||||
await expect(folder).not.toBeChecked();
|
||||
await expect(dialog.getByTitle(project, { exact: true })).toBeVisible();
|
||||
await expect(dialog.getByTitle(parent, { exact: true })).toBeVisible();
|
||||
await folder.check();
|
||||
await expect(folderAction).toHaveCount(1);
|
||||
await expect(projectAction).toHaveCount(0);
|
||||
for (const selector of ["[data-dialog-body]", "[data-dialog-footer]"]) {
|
||||
expect(await dialog.locator(selector).evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
}
|
||||
await expect(restricted).toBeInViewport({ ratio: 1 });
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(dialog).toBeHidden();
|
||||
expect(await ipcCalls(page, "project_trust_set")).toEqual([]);
|
||||
expect(await ipcCalls(page, "open_project")).toEqual([]);
|
||||
|
||||
await open();
|
||||
await expect(projectAction).toBeVisible();
|
||||
await expect(folder).not.toBeChecked();
|
||||
await folder.check();
|
||||
await restricted.click();
|
||||
await expect(dialog).toBeHidden();
|
||||
expect(await ipcCalls(page, "project_trust_set")).toEqual([{ path: project, trusted: false, folder: false }]);
|
||||
await expect.poll(() => ipcCalls(page, "open_project")).toEqual([{ path: project }]);
|
||||
});
|
||||
@@ -1,88 +0,0 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Quick Evaluate opens an object tree that fits the editor and returns focus on Escape", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 445, height: 500 });
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(async () => {
|
||||
const path = "/dev/acme-api/settlement.py";
|
||||
const h = window.__ipc.handlers;
|
||||
const value = (name: string, text: string, typeName: string, variablesReference = 0) => ({
|
||||
name,
|
||||
value: text,
|
||||
typeName,
|
||||
variablesReference,
|
||||
evaluateName: name,
|
||||
});
|
||||
h.fs_probe = () => ({ size: 48, binary: false, tooLarge: false });
|
||||
h.fs_read_text = () => "summary = {}\nsubtotal = 42\n";
|
||||
h.debug_evaluate_in = ({ expression }) =>
|
||||
expression === "summary" ? value("summary", "{...}", "dict", 101) : value("subtotal", "42", "int");
|
||||
h.debug_variables = ({ reference }) =>
|
||||
reference === 101
|
||||
? [value("audit", "{...}", "dict", 102), value("total", "47.74", "float")]
|
||||
: Array.from({ length: 22 }, (_, i) => value(`entry${i.toString().padStart(2, "0")}`, String(i), "int"));
|
||||
h.debug_scopes = () => [];
|
||||
const servicesModule = "/src/workbench/contributions.ts";
|
||||
const { editorService } = await import(/* @vite-ignore */ servicesModule);
|
||||
await editorService().openFile(path, { focus: true });
|
||||
const debugModule = "/src/features/debugger/state.ts";
|
||||
const { adoptSession, publishContext } = await import(/* @vite-ignore */ debugModule);
|
||||
adoptSession(91, {
|
||||
name: "Checkout",
|
||||
adapter: "debugpy",
|
||||
status: "paused",
|
||||
selectedFrame: 11,
|
||||
frames: [{ id: 11, name: "checkout", path, line: 0, column: 0, presentationHint: null }],
|
||||
});
|
||||
publishContext();
|
||||
});
|
||||
const editor = page.locator(".cm-editor");
|
||||
const content = editor.locator(".cm-content");
|
||||
await expect(content).toBeVisible();
|
||||
await content.evaluate((el) => {
|
||||
const { view } = (el as HTMLElement & { cmTile: { view: EditorView } }).cmTile;
|
||||
view.dispatch({ changes: { from: 0, to: view.state.doc.length, insert: "summary = {}\nsubtotal = 42\n" } });
|
||||
});
|
||||
const evaluate = (line: number) =>
|
||||
content.evaluate(async (el, lineNo) => {
|
||||
const { view } = (el as HTMLElement & { cmTile: { view: EditorView } }).cmTile;
|
||||
view.dispatch({ selection: { anchor: view.state.doc.line(lineNo).from + 2 } });
|
||||
const actionModule = "/src/platform/actions.ts";
|
||||
await (await import(/* @vite-ignore */ actionModule)).executeAction("debug.quickEvaluate");
|
||||
}, line);
|
||||
|
||||
await evaluate(1);
|
||||
const hint = page.locator(".cm-lsp-hint");
|
||||
await expect(hint).toBeVisible();
|
||||
await expect(hint.getByRole("button", { name: "Expand value" })).toHaveCount(0);
|
||||
const tree = hint.getByRole("tree", { name: "summary" });
|
||||
await expect(tree).toBeFocused();
|
||||
await expect(tree.getByText("audit", { exact: true })).toBeVisible();
|
||||
await page.setViewportSize({ width: 400, height: 360 });
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const editorBox = (await editor.boundingBox())!;
|
||||
const hintBox = (await hint.boundingBox())!;
|
||||
return hintBox.x >= editorBox.x - 1 && hintBox.x + hintBox.width <= editorBox.x + editorBox.width + 1;
|
||||
})
|
||||
.toBe(true);
|
||||
|
||||
await tree.getByText("audit", { exact: true }).click();
|
||||
await tree.press("ArrowRight");
|
||||
await expect(tree.getByText("entry00", { exact: true })).toBeVisible();
|
||||
expect(await tree.evaluate((el) => el.scrollHeight > el.clientHeight)).toBe(true);
|
||||
await tree.press("Escape");
|
||||
await expect(hint).toBeHidden();
|
||||
await expect(content).toBeFocused();
|
||||
|
||||
await evaluate(2);
|
||||
await expect(hint.getByRole("tree")).toHaveCount(0);
|
||||
await expect(hint).toHaveText(/subtotal\s*=\s*42/);
|
||||
expect(await ipcCalls(page, "debug_evaluate_in")).toEqual([
|
||||
{ session: 91, frameId: 11, expression: "summary", context: "watch" },
|
||||
{ session: 91, frameId: 11, expression: "subtotal", context: "watch" },
|
||||
]);
|
||||
});
|
||||
@@ -1,74 +0,0 @@
|
||||
import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Rollback fits a short window and scopes its options to checked files", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 410, height: 330 });
|
||||
await stubDesktop(page);
|
||||
const root = "/dev/settlement-engine";
|
||||
const added = `${root}/ledger/additional-settlement-schedule.txt`;
|
||||
const deleted = `${root}/ledger/retired-settlement-routing.txt`;
|
||||
const modified = Array.from({ length: 16 }, (_, i) => `${root}/ledger/merchant-settlement-batch-${i + 1}.txt`);
|
||||
|
||||
await page.evaluate(
|
||||
async ({ root, added, deleted, modified }) => {
|
||||
const status = [
|
||||
{ path: added, staged: "added", unstaged: null },
|
||||
{ path: deleted, staged: "deleted", unstaged: null },
|
||||
...modified.map((path) => ({ path, staged: null, unstaged: "modified" })),
|
||||
].map((file) => ({ ...file, relPath: file.path.slice(root.length + 1), renamedFrom: null }));
|
||||
const branch = { head: "main", headCommit: "c1", upstream: null, ahead: 0, behind: 0, operation: null };
|
||||
const h = window.__ipc.handlers;
|
||||
h.vcs_branch_info = () => branch;
|
||||
h.vcs_roots = () => [{ root, ...branch }];
|
||||
h.vcs_status = () => status;
|
||||
h.vcs_unstage = () => null;
|
||||
h.vcs_discard = () => null;
|
||||
|
||||
const storeModule = "/src/features/vcs/store.ts";
|
||||
const { useVcs } = await import(/* @vite-ignore */ storeModule);
|
||||
useVcs.setState({ available: true, root, repo: root, roots: [root], branch, status });
|
||||
const contextModule = "/src/platform/context.ts";
|
||||
const { setContext } = await import(/* @vite-ignore */ contextModule);
|
||||
setContext("vcsAvailable", true);
|
||||
const actionsModule = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ actionsModule);
|
||||
await executeAction("vcs.rollback", [root]);
|
||||
},
|
||||
{ root, added, deleted, modified },
|
||||
);
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "Rollback Changes", exact: true });
|
||||
const tree = dialog.getByRole("tree", { name: "Files to roll back" });
|
||||
const body = dialog.locator("[data-dialog-body]");
|
||||
await expect(tree).toBeVisible();
|
||||
expect(await body.evaluate((el) => el.scrollHeight - el.clientHeight)).toBeLessThanOrEqual(1);
|
||||
expect(await body.evaluate((el) => el.scrollWidth - el.clientWidth)).toBe(0);
|
||||
expect(await tree.evaluate((el) => el.scrollHeight > el.clientHeight)).toBe(true);
|
||||
await expect(tree).toBeFocused();
|
||||
await expect(tree.getByTitle("ledger/additional-settlement-schedule.txt", { exact: true })).toBeVisible();
|
||||
|
||||
const status = dialog.getByRole("status");
|
||||
const deleteCopies = dialog.getByRole("checkbox", { name: "Delete local copies of added files" });
|
||||
const rollback = dialog.getByRole("button", { name: "Rollback", exact: true });
|
||||
await expect(status).toHaveText("1 added16 modified1 deleted");
|
||||
await expect(deleteCopies).toBeEnabled();
|
||||
await expect(deleteCopies).not.toBeChecked();
|
||||
await deleteCopies.check();
|
||||
await tree.getByRole("checkbox", { name: "Include additional-settlement-schedule.txt" }).uncheck();
|
||||
await expect(deleteCopies).toBeDisabled();
|
||||
await expect(status).toHaveText("16 modified1 deleted");
|
||||
|
||||
const rootCheckbox = tree.getByRole("checkbox", { name: "Include settlement-engine", exact: true });
|
||||
await expect(rootCheckbox).toHaveAttribute("aria-checked", "mixed");
|
||||
await rootCheckbox.click();
|
||||
await rootCheckbox.uncheck();
|
||||
await expect(rollback).toBeDisabled();
|
||||
await expect(status).toHaveText("No files selected");
|
||||
|
||||
await tree.getByRole("checkbox", { name: "Include merchant-settlement-batch-1.txt", exact: true }).check();
|
||||
await expect(status).toHaveText("1 modified");
|
||||
await expect(deleteCopies).toBeDisabled();
|
||||
await rollback.click();
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect.poll(() => ipcCalls(page, "vcs_discard")).toEqual([{ paths: [modified[0]] }]);
|
||||
expect(await ipcCalls(page, "vcs_unstage")).toEqual([]);
|
||||
});
|
||||
@@ -1,103 +0,0 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, ipcCalls, openFromTree, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Safe Delete lays out the search option and makes View Usages the default in a narrow window", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const editor = await openFromTree(page, "App.tsx");
|
||||
await page.setViewportSize({ width: 425, height: 500 });
|
||||
const content = editor.locator(".cm-content");
|
||||
const symbol = "reconcileOutstandingSupplierAdjustmentsForTheMonthlySettlementArchive";
|
||||
const source = [
|
||||
`export function ${symbol}() {`,
|
||||
" return 1;",
|
||||
"}",
|
||||
"",
|
||||
`const debit = ${symbol}();`,
|
||||
`const credit = ${symbol}();`,
|
||||
].join("\n");
|
||||
await content.evaluate(
|
||||
(element, { source, symbol }) => {
|
||||
const view = (element as HTMLElement & { cmTile: { view: EditorView } }).cmTile.view;
|
||||
view.dispatch({
|
||||
changes: { from: 0, to: view.state.doc.length, insert: source },
|
||||
selection: { anchor: source.indexOf(symbol) + 1 },
|
||||
});
|
||||
view.focus();
|
||||
},
|
||||
{ source, symbol },
|
||||
);
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
({ source, symbol }) => {
|
||||
const path = "/dev/acme-api/App.tsx";
|
||||
const range = (line: number, col: number, end = col + symbol.length) => ({
|
||||
start: { line, col },
|
||||
end: { line, col: end },
|
||||
});
|
||||
const selection = range(0, "export function ".length);
|
||||
const handlers = window.__ipc.handlers;
|
||||
handlers.lsp_goto = () => [{ path, range: selection }];
|
||||
handlers.doc_outline = () => [
|
||||
{
|
||||
name: symbol,
|
||||
detail: null,
|
||||
kind: "function",
|
||||
range: { start: { line: 0, col: 0 }, end: { line: 2, col: 1 } },
|
||||
selection_range: selection,
|
||||
children: [],
|
||||
},
|
||||
];
|
||||
handlers.languages = () => [];
|
||||
handlers.lsp_references = () => ({
|
||||
locations: [
|
||||
{ path, range: range(4, "const debit = ".length) },
|
||||
{ path, range: range(5, "const credit = ".length) },
|
||||
],
|
||||
incomplete: null,
|
||||
});
|
||||
handlers.fs_read_text = () => source;
|
||||
},
|
||||
{ source, symbol },
|
||||
);
|
||||
const openSafeDelete = () =>
|
||||
page.evaluate(async () => {
|
||||
const module = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ module);
|
||||
void executeAction("refactor.safeDelete");
|
||||
});
|
||||
const usageSearches = async () => (await ipcCalls(page, "lsp_references")).filter((call) => call.projectWide);
|
||||
|
||||
await openSafeDelete();
|
||||
const prompt = page.getByRole("dialog", { name: "Safe Delete", exact: true });
|
||||
await expect(prompt.locator("[data-dialog-titlebar]")).toHaveText("Safe Delete");
|
||||
const description = prompt.getByText(`Delete Function '${symbol}'?`);
|
||||
const commentSearch = prompt.getByRole("checkbox", { name: "Search in comments and strings" });
|
||||
await expect(commentSearch).toBeChecked();
|
||||
const expectedLeft = (await description.boundingBox())!.x;
|
||||
expect((await commentSearch.boundingBox())!.x).toBeCloseTo(expectedLeft, 0);
|
||||
await expect(prompt.locator("[data-dialog-body]")).toContainText(symbol);
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(prompt).toBeHidden();
|
||||
await expect(content).toBeFocused();
|
||||
expect(await usageSearches()).toHaveLength(0);
|
||||
|
||||
await openSafeDelete();
|
||||
await commentSearch.uncheck();
|
||||
await prompt.getByRole("button", { name: "OK", exact: true }).click();
|
||||
const conflict = page.getByRole("dialog", { name: "Usages Detected", exact: true });
|
||||
await expect(conflict.getByRole("heading", { name: "2 usages found" })).toBeVisible();
|
||||
await expect(conflict.getByText(`Function '${symbol}' has 2 usages that are not safe to delete.`)).toBeVisible();
|
||||
for (const button of ["View Usages", "Delete Anyway", "Cancel"]) {
|
||||
await expect(conflict.getByRole("button", { name: button, exact: true })).toBeInViewport({ ratio: 1 });
|
||||
}
|
||||
expect(
|
||||
await conflict.locator("[data-dialog-body]").evaluate((element) => element.scrollWidth - element.clientWidth),
|
||||
).toBe(0);
|
||||
await expect(conflict.getByRole("button", { name: "View Usages" })).toBeFocused();
|
||||
await page.keyboard.press("Enter");
|
||||
await expect(conflict).toBeHidden();
|
||||
await expect(page.getByRole("region", { name: "Find Usages", exact: true })).toBeVisible();
|
||||
await expect(content).toContainText("export function");
|
||||
expect(await usageSearches()).toHaveLength(1);
|
||||
});
|
||||
@@ -1,86 +0,0 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test("the scratch language chooser fits short windows and keeps recents separate from search results", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 470, height: 400 });
|
||||
const long = "Zebra Configuration Language for Regional Settlement and Reconciliation Pipelines";
|
||||
await page.evaluate(async (long) => {
|
||||
const scratch = "/src/features/scratch/scratches.ts";
|
||||
const store = "/src/features/scratch/store.ts";
|
||||
const actions = "/src/platform/actions.ts";
|
||||
const { setScratchBackend } = await import(/* @vite-ignore */ scratch);
|
||||
const { rememberLanguage } = await import(/* @vite-ignore */ store);
|
||||
setScratchBackend({
|
||||
dataDir: async () => "/test-app-data",
|
||||
listNames: async () => [],
|
||||
createDir: async () => {},
|
||||
createFile: async () => {},
|
||||
languages: async () => [
|
||||
...Array.from({ length: 24 }, (_, i) => {
|
||||
const n = String(i + 1).padStart(2, "0");
|
||||
return { id: `config-${n}`, name: `Configuration ${n}`, ext: `cfg${n}` };
|
||||
}),
|
||||
{ id: "json", name: "JSON", ext: "json" },
|
||||
{ id: "python", name: "Python", ext: "py" },
|
||||
{ id: "zebra", name: long, ext: "zebra" },
|
||||
],
|
||||
open: async (path: string) => localStorage.setItem("scratch-layout-opened", path),
|
||||
});
|
||||
rememberLanguage("json");
|
||||
rememberLanguage("python");
|
||||
await (await import(/* @vite-ignore */ actions)).executeAction("file.newScratchFile");
|
||||
}, long);
|
||||
|
||||
const dialog = page.getByRole("dialog", { name: "New Scratch File", exact: true });
|
||||
const input = dialog.getByRole("textbox", { name: "Filter languages" });
|
||||
await expect(input).toBeFocused();
|
||||
const list = dialog.getByRole("listbox", { name: "Languages" });
|
||||
for (let i = 0; i < 3; i++) await input.press("PageDown");
|
||||
const last = list.getByRole("option", { name: long, exact: true });
|
||||
await expect(last).toHaveAttribute("aria-selected", "true");
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const popup = (await dialog.boundingBox())!;
|
||||
const item = (await last.boundingBox())!;
|
||||
return item.y + item.height - popup.y - popup.height;
|
||||
})
|
||||
.toBeLessThanOrEqual(1);
|
||||
await expect(last).toBeInViewport({ ratio: 0.99 });
|
||||
await expect(last.getByTitle(long)).toBeVisible();
|
||||
await expect(input).toBeInViewport({ ratio: 1 });
|
||||
|
||||
await input.fill("python");
|
||||
const python = list.getByRole("option", { name: "Python", exact: true });
|
||||
await expect(python).toHaveAttribute("aria-selected", "true");
|
||||
await expect(list.getByRole("separator")).toHaveCount(0);
|
||||
await input.fill("");
|
||||
const divider = list.getByRole("separator");
|
||||
await expect(divider).toBeVisible();
|
||||
await expect(python).toHaveAttribute("aria-selected", "true");
|
||||
await input.press("ArrowDown");
|
||||
const json = list.getByRole("option", { name: "JSON", exact: true });
|
||||
await expect(json).toHaveAttribute("aria-selected", "true");
|
||||
await input.press("ArrowDown");
|
||||
const first = list.getByRole("option", { name: "Configuration 01", exact: true });
|
||||
await expect(first).toHaveAttribute("aria-selected", "true");
|
||||
expect((await divider.boundingBox())!.y).toBeLessThan((await first.boundingBox())!.y);
|
||||
expect(await input.getAttribute("aria-activedescendant")).toBe(await first.getAttribute("id"));
|
||||
await page.setViewportSize({ width: 640, height: 520 });
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const bounds = (await dialog.boundingBox())!;
|
||||
return Math.abs(bounds.x + bounds.width / 2 - 320);
|
||||
})
|
||||
.toBeLessThanOrEqual(1);
|
||||
await expect(input).toBeFocused();
|
||||
|
||||
await input.fill("zzz");
|
||||
await expect(dialog.getByText("No matching languages")).toBeVisible();
|
||||
await input.fill("json");
|
||||
await input.press("Enter");
|
||||
await expect(dialog).toBeHidden();
|
||||
await expect
|
||||
.poll(() => page.evaluate(() => localStorage.getItem("scratch-layout-opened")))
|
||||
.toBe("/test-app-data/scratches/scratch.json");
|
||||
});
|
||||
@@ -1,94 +0,0 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("selection history keeps a full-width diff above a keyboard-resizable revision table", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 1140, height: 740 });
|
||||
const filename = "QuarterlyCrossBorderSettlementReconciliationProjection.ts";
|
||||
const path = `/dev/acme-api/modules/${filename}`;
|
||||
const lastMessage = "Introduce the reconciliation projection for pending cross-border merchant settlements";
|
||||
await page.evaluate(async (path) => {
|
||||
const backend = "/src/editor/core/backend.ts";
|
||||
(await import(/* @vite-ignore */ backend))
|
||||
.docBackend()
|
||||
.files.set(path, "export const pending = 0;\nconst projection = uncommitted;\n");
|
||||
const service = "/src/workbench/contributions.ts";
|
||||
await (await import(/* @vite-ignore */ service)).editorService().openFile(path);
|
||||
}, path);
|
||||
const editor = page.locator(".cm-content");
|
||||
await expect(editor).toContainText("uncommitted");
|
||||
await editor.evaluate((el) => {
|
||||
const view = (el as HTMLElement & { cmTile: { view: EditorView } }).cmTile.view;
|
||||
const line = view.state.doc.line(2);
|
||||
view.dispatch({ selection: { anchor: line.from, head: line.to } });
|
||||
view.focus();
|
||||
});
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
async ({ path, lastMessage }) => {
|
||||
window.__ipc.handlers.cancel_request = () => null;
|
||||
window.__ipc.handlers.vcs_block_history = () => ({
|
||||
headLines: [1, 1],
|
||||
revisions: Array.from({ length: 22 }, (_, i) => ({
|
||||
id: (i + 16).toString(16).padStart(40, "0"),
|
||||
shortId: (i + 16).toString(16).padStart(7, "0"),
|
||||
author: "Alexandra Reconciliation Coordinator",
|
||||
email: "[email protected]",
|
||||
timeMs: 1738329600000 - i * 86400000,
|
||||
summary: i === 21 ? lastMessage : `Update reconciliation estimate ${22 - i}`,
|
||||
path,
|
||||
before: `const projection = estimate${21 - i};\n`,
|
||||
after: `const projection = estimate${22 - i};\n`,
|
||||
beforeLine: 1,
|
||||
afterLine: 1,
|
||||
})),
|
||||
});
|
||||
const actions = "/src/platform/actions.ts";
|
||||
await (await import(/* @vite-ignore */ actions)).executeAction("vcs.showHistoryForSelection");
|
||||
},
|
||||
{ path, lastMessage },
|
||||
);
|
||||
|
||||
const diff = page.locator(".cm-mergeView");
|
||||
await expect(diff).toContainText("uncommitted");
|
||||
const revisions = page.getByRole("grid", { name: "Revisions" });
|
||||
const history = revisions.or(page.getByRole("listbox", { name: "Revisions" }));
|
||||
await expect(history).toBeVisible();
|
||||
const preview = (await diff.boundingBox())!;
|
||||
const list = (await history.boundingBox())!;
|
||||
expect(list.y).toBeGreaterThanOrEqual(preview.y + preview.height - 1);
|
||||
expect(preview.width).toBeGreaterThanOrEqual(list.width - 2);
|
||||
|
||||
await expect(revisions.getByRole("columnheader")).toHaveText(["Revision", "Date", "Author", "Message"]);
|
||||
const divider = page.getByRole("separator", { name: "Revisions", exact: true });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
const initial = (await divider.boundingBox())!.y;
|
||||
await divider.press("ArrowUp");
|
||||
await expect.poll(async () => (await divider.boundingBox())!.y).toBeLessThan(initial);
|
||||
await expect(revisions.getByRole("row", { selected: true })).toContainText("Local Changes");
|
||||
|
||||
await page.setViewportSize({ width: 490, height: 620 });
|
||||
await expect(divider).toHaveAttribute("aria-orientation", "horizontal");
|
||||
await expect(page.getByTitle(`${filename}:2-2`, { exact: true })).toBeVisible();
|
||||
const body = revisions.getByRole("rowgroup");
|
||||
await body.press("End");
|
||||
const last = revisions.getByRole("row", { selected: true });
|
||||
await expect(last.getByRole("gridcell", { name: lastMessage, exact: true })).toHaveAttribute("title", lastMessage);
|
||||
await expect
|
||||
.poll(async () => {
|
||||
const listBounds = (await body.boundingBox())!;
|
||||
const rowBounds = (await last.boundingBox())!;
|
||||
return Math.max(listBounds.y - rowBounds.y, rowBounds.y + rowBounds.height - listBounds.y - listBounds.height);
|
||||
})
|
||||
.toBeLessThanOrEqual(1);
|
||||
const headers = revisions.getByRole("columnheader");
|
||||
const cells = last.getByRole("gridcell");
|
||||
for (let i = 0; i < 4; i++) {
|
||||
expect(
|
||||
Math.abs((await headers.nth(i).boundingBox())!.x - (await cells.nth(i).boundingBox())!.x),
|
||||
).toBeLessThanOrEqual(1);
|
||||
}
|
||||
expect(await body.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
await expect(diff).toContainText("estimate1");
|
||||
});
|
||||
@@ -184,7 +184,6 @@ test("Language Servers page installs a tool with progress (in-memory installer)"
|
||||
test("font picker supports manual families and CJK fallback in browser development", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings" });
|
||||
const preview = dialog.getByRole("textbox", { name: "Font preview", exact: true });
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Typography Settings");
|
||||
await dialog.getByRole("treeitem", { name: "Font", exact: true }).click();
|
||||
const family = dialog.getByRole("combobox", { name: "Font", exact: true });
|
||||
@@ -202,16 +201,16 @@ test("font picker supports manual families and CJK fallback in browser developme
|
||||
await family.fill("Inter");
|
||||
await family.press("Enter");
|
||||
// Computed styles drop redundant quotes around single-token families ("Inter" -> Inter).
|
||||
await expect(preview).toHaveCSS("font-family", /^Inter, "Inter Variable",/);
|
||||
await expect(dialog.getByLabel("Font preview")).toHaveCSS("font-family", /^Inter, "Inter Variable",/);
|
||||
const fallback = dialog.getByRole("combobox", { name: "Fallback font", exact: true });
|
||||
await family.fill("Maple Mono NF");
|
||||
await family.press("Enter");
|
||||
await fallback.fill("Inter");
|
||||
await fallback.press("Enter");
|
||||
await expect(preview).toHaveCSS("font-family", /Maple Mono NF.*Inter Variable/);
|
||||
await expect(dialog.getByLabel("Font preview")).toHaveCSS("font-family", /Maple Mono NF.*Inter Variable/);
|
||||
await fallback.fill("思源宋体");
|
||||
await fallback.press("Enter");
|
||||
await expect(preview).toHaveCSS("font-family", /思源宋体/);
|
||||
await expect(dialog.getByLabel("Font preview")).toHaveCSS("font-family", /思源宋体/);
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await expect(dialog).toBeHidden();
|
||||
});
|
||||
@@ -69,53 +69,20 @@ test("every color scheme page keeps its attribute tree visible", async ({ workbe
|
||||
}
|
||||
});
|
||||
|
||||
test("Live Templates gives the editor the full settings pane width and keeps variable fields reachable", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await expect(dialog).toBeVisible();
|
||||
await page.evaluate(async () => {
|
||||
const path = "/src/features/settings/model/staging.ts";
|
||||
(await import(/* @vite-ignore */ path)).selectPage("editor.liveTemplates");
|
||||
for (const id of ["editor.fileTemplates", "editor.liveTemplates"]) {
|
||||
test(`${id} keeps its editor reachable beside the template list`, async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
await expect(page.getByRole("dialog", { name: "Settings", exact: true })).toBeVisible();
|
||||
await page.evaluate(async (id) => {
|
||||
const path = "/src/features/settings/model/staging.ts";
|
||||
(await import(/* @vite-ignore */ path)).selectPage(id);
|
||||
}, id);
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
const editor = page.locator("[class*='split'] > [class*='editor']").first();
|
||||
await expect(editor).toBeAttached();
|
||||
expect((await editor.boundingBox())!.width).toBeGreaterThan(200);
|
||||
});
|
||||
const list = dialog.getByRole("listbox", { name: "Live templates" });
|
||||
const body = dialog.getByRole("textbox", { name: "Template text" });
|
||||
await dialog.getByRole("button", { name: "Add Template" }).click();
|
||||
await expect(body).toBeVisible();
|
||||
const listBounds = (await list.boundingBox())!;
|
||||
const bodyBounds = (await body.boundingBox())!;
|
||||
expect(bodyBounds.y).toBeGreaterThan(listBounds.y + listBounds.height);
|
||||
expect(bodyBounds.width).toBeGreaterThan(listBounds.width - 32);
|
||||
|
||||
const handle = dialog.getByRole("separator", { name: "Resize template panes" });
|
||||
await expect(handle).toHaveAttribute("aria-orientation", "horizontal");
|
||||
await handle.press("ArrowDown");
|
||||
await expect.poll(async () => (await list.boundingBox())!.height).toBeGreaterThan(listBounds.height + 10);
|
||||
|
||||
await dialog.getByRole("textbox", { name: "Abbreviation" }).fill("settlement");
|
||||
await dialog.getByRole("textbox", { name: "Filter templates" }).fill("settlement");
|
||||
await expect(list.getByRole("option")).toHaveCount(1);
|
||||
await expect(list.getByRole("option")).toHaveAttribute("aria-selected", "true");
|
||||
await body.fill("record($SETTLEMENT_REFERENCE_IDENTIFIER$, $AMOUNT$)$END$");
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 600 });
|
||||
await body.scrollIntoViewIfNeeded();
|
||||
await expect(body).toBeInViewport({ ratio: 0.98 });
|
||||
const narrowList = (await list.boundingBox())!;
|
||||
const narrowBody = (await body.boundingBox())!;
|
||||
expect(narrowBody.x + narrowBody.width).toBeLessThanOrEqual(narrowList.x + narrowList.width);
|
||||
const variables = dialog.getByRole("table");
|
||||
const expression = variables.getByRole("textbox", { name: "SETTLEMENT_REFERENCE_IDENTIFIER expression" });
|
||||
await expression.scrollIntoViewIfNeeded();
|
||||
await expect(expression).toBeInViewport({ ratio: 1 });
|
||||
await expression.fill("fileName()");
|
||||
await expect(expression).toHaveValue("fileName()");
|
||||
await expect(
|
||||
variables.getByRole("checkbox", { name: "Skip SETTLEMENT_REFERENCE_IDENTIFIER if defined" }),
|
||||
).toBeVisible();
|
||||
expect(await variables.evaluate((element) => element.scrollWidth - element.clientWidth)).toBe(0);
|
||||
});
|
||||
}
|
||||
|
||||
test("Project Structure keeps every details pane usable in a compact window", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+;");
|
||||
|
||||
@@ -1,67 +0,0 @@
|
||||
import type { Page } from "@playwright/test";
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
async function openSmartKeys(page: Page) {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Smart Keys");
|
||||
await dialog.getByRole("treeitem", { name: "Smart Keys", exact: true }).click();
|
||||
return dialog;
|
||||
}
|
||||
|
||||
test("backspace and paste controls align below Enter options in Smart Keys", async ({ workbench: page }) => {
|
||||
const dialog = await openSmartKeys(page);
|
||||
const enter = dialog.getByRole("region", { name: "Enter", exact: true });
|
||||
const unindent = dialog.getByRole("button", { name: /^Unindent(?: on Backspace)?$/ });
|
||||
const paste = dialog.getByRole("button", { name: "Reformat on paste", exact: true });
|
||||
const escape = dialog.getByRole("checkbox", { name: "Escape text on paste in string literals", exact: true });
|
||||
|
||||
for (const width of [1120, 520]) {
|
||||
await page.setViewportSize({ width, height: 760 });
|
||||
await expect(unindent).toBeInViewport({ ratio: 0.98 });
|
||||
await expect(paste).toBeInViewport({ ratio: 0.98 });
|
||||
const enterBox = (await enter.boundingBox())!;
|
||||
const unindentBox = (await unindent.boundingBox())!;
|
||||
const pasteBox = (await paste.boundingBox())!;
|
||||
expect(unindentBox.y).toBeGreaterThan(enterBox.y + enterBox.height);
|
||||
expect(pasteBox.y).toBeGreaterThanOrEqual(unindentBox.y + unindentBox.height);
|
||||
expect(Math.abs(pasteBox.x - unindentBox.x)).toBeLessThan(1);
|
||||
expect((await escape.boundingBox())!.y).toBeGreaterThanOrEqual(pasteBox.y + pasteBox.height);
|
||||
}
|
||||
|
||||
await paste.click();
|
||||
await expect(page.getByRole("option", { name: "Indent Each Line", exact: true })).toBeInViewport();
|
||||
});
|
||||
|
||||
test("Smart Keys keeps backspace and paste preferences independent across Apply and Cancel", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const setOption = async (label: string, option: string) => {
|
||||
await page
|
||||
.getByRole("dialog", { name: "Settings", exact: true })
|
||||
.getByRole("button", { name: label, exact: true })
|
||||
.click();
|
||||
await page.getByRole("option", { name: option, exact: true }).click();
|
||||
};
|
||||
|
||||
const dialog = await openSmartKeys(page);
|
||||
await setOption("Unindent on Backspace", "To nearest indent position");
|
||||
await setOption("Reformat on paste", "Indent Block");
|
||||
await dialog.getByRole("button", { name: "Apply", exact: true }).click();
|
||||
await expect(dialog.getByRole("button", { name: "Apply", exact: true })).toBeDisabled();
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
|
||||
const reopened = await openSmartKeys(page);
|
||||
await expect(reopened.getByRole("button", { name: "Unindent on Backspace", exact: true })).toHaveText(
|
||||
"To nearest indent position",
|
||||
);
|
||||
await expect(reopened.getByRole("button", { name: "Reformat on paste", exact: true })).toHaveText("Indent Block");
|
||||
await setOption("Reformat on paste", "None");
|
||||
await reopened.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
|
||||
const final = await openSmartKeys(page);
|
||||
await expect(final.getByRole("button", { name: "Unindent on Backspace", exact: true })).toHaveText(
|
||||
"To nearest indent position",
|
||||
);
|
||||
await expect(final.getByRole("button", { name: "Reformat on paste", exact: true })).toHaveText("Indent Block");
|
||||
});
|
||||
@@ -1,74 +0,0 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, openFromTree, test } from "./fixtures";
|
||||
|
||||
test("Surround With keeps its title and keyboard-selected actions visible in a short window", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 680, height: 320 });
|
||||
const editor = await openFromTree(page, "App.tsx");
|
||||
const content = editor.locator(".cm-content");
|
||||
const source = [
|
||||
"const fee = 5;",
|
||||
"",
|
||||
"function settle(amount: number) {",
|
||||
" const adjusted = amount - fee;",
|
||||
" const receipt = adjusted.toString();",
|
||||
" console.log(receipt);",
|
||||
" return adjusted;",
|
||||
"}",
|
||||
].join("\n");
|
||||
const selectedText = " console.log(receipt);";
|
||||
await content.evaluate(
|
||||
(node, { source, selectedText }) => {
|
||||
const view = (node as HTMLElement & { cmTile: { view: EditorView } }).cmTile.view;
|
||||
const start = source.indexOf(selectedText);
|
||||
view.dispatch({
|
||||
changes: { from: 0, to: view.state.doc.length, insert: source },
|
||||
selection: { anchor: start, head: start + selectedText.length },
|
||||
scrollIntoView: true,
|
||||
});
|
||||
view.focus();
|
||||
},
|
||||
{ source, selectedText },
|
||||
);
|
||||
const openSurround = () =>
|
||||
page.evaluate(async () => {
|
||||
const module = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ module);
|
||||
await executeAction("code.surroundWith");
|
||||
});
|
||||
|
||||
await openSurround();
|
||||
const popup = page.getByRole("dialog", { name: "Surround With", exact: true });
|
||||
const title = popup.getByText("Surround With", { exact: true });
|
||||
const list = popup.getByRole("listbox");
|
||||
await expect(title).toBeInViewport({ ratio: 1 });
|
||||
await expect.poll(() => list.evaluate((node) => node.scrollHeight - node.clientHeight)).toBeGreaterThan(0);
|
||||
await expect.poll(() => popup.evaluate((node) => node.scrollHeight - node.clientHeight)).toBe(0);
|
||||
|
||||
const first = list.getByRole("option", { name: /^1\.?\s+if$/ });
|
||||
await expect(first).toHaveAttribute("aria-selected", "true");
|
||||
const action = first.getByText("if", { exact: true });
|
||||
const mnemonic = first.getByText(/^1\.?$/, { exact: true });
|
||||
expect((await mnemonic.boundingBox())!.x + (await mnemonic.boundingBox())!.width).toBeLessThan(
|
||||
(await action.boundingBox())!.x,
|
||||
);
|
||||
expect(await action.evaluate((node) => getComputedStyle(node).fontSize)).toBe("13px");
|
||||
await page.keyboard.press("End");
|
||||
const last = list.getByRole("option", { name: /!\(expr\)/ });
|
||||
await expect(last).toHaveAttribute("aria-selected", "true");
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(title).toBeInViewport({ ratio: 1 });
|
||||
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(popup).toBeHidden();
|
||||
await expect(content).toBeFocused();
|
||||
await expect(content).toContainText("console.log(receipt);");
|
||||
|
||||
await openSurround();
|
||||
await expect(first).toBeVisible();
|
||||
await page.keyboard.press("1");
|
||||
await expect(popup).toBeHidden();
|
||||
await expect(content).toContainText(/if \([^)]*\) \{/);
|
||||
await expect(content).toContainText("console.log(receipt);");
|
||||
});
|
||||
@@ -2,7 +2,7 @@ Manifest-Version: 1.0
|
||||
Bundle-ManifestVersion: 2
|
||||
Bundle-Name: OpenIDEA JVM inspect
|
||||
Bundle-SymbolicName: ai.openidea.jvminspect;singleton:=true
|
||||
Bundle-Version: 1.1.1
|
||||
Bundle-Version: 1.1.0
|
||||
Bundle-RequiredExecutionEnvironment: JavaSE-21
|
||||
Require-Bundle: org.eclipse.jdt.ls.core,org.eclipse.core.runtime,
|
||||
org.eclipse.equinox.common,org.eclipse.jdt.debug,org.eclipse.core.resources
|
||||
|
||||
@@ -123,13 +123,6 @@ ordinary `executeCommand` error.
|
||||
invoke go on (ide-dap does that unseen while the trace runs).
|
||||
The outcome is forced into the frame before it is pinned, so the pending return keeps it reachable;
|
||||
should it be collected before that, the program gets the cancel exception and the trace fails.
|
||||
- An exception the terminal threw (the cancel exception of `abort` included) ends the client's
|
||||
`stepOut` in the program's catch. Nothing catching it, the thread would die with no stop left to
|
||||
`collect` in, so before parking the bundle adds an uncaught-exception request on the thread,
|
||||
suspending it: the step-out ends at that throw instead, as a java-debug `exception` stop, and a
|
||||
resume lets the exception end the thread as it would have. Skipped when an enabled request of
|
||||
java-debug's already reports uncaught throws of that type (one stop, not two). `collect` deletes it;
|
||||
after `collect` a release no longer resumes the parked event, since that stop keeps the parked frames.
|
||||
- `wait` returns as soon as the trace leaves `running`, or after `ms`, at most 30 000. While the
|
||||
terminal runs it also checks every 500 ms whether the VM began to shut down
|
||||
(`jdk.internal.misc.VM.initLevel`): `System.exit` in a lambda makes the VM wait forever to report
|
||||
@@ -211,7 +204,7 @@ Java 21. The recorder is compiled by the `javac` on `PATH` with `--release 8`, s
|
||||
run Java 8. Build twice and compare: two builds of the checked-in jar gave
|
||||
|
||||
```
|
||||
4ab30723afe1254b991d9457ea66271109f397a17b238870572283aad73338ad openidea-jvm-inspect.jar
|
||||
22980a16bd8e303d67ed2e04d76d8974f2d3981120c26e6d9afa47ba361b1503 openidea-jvm-inspect.jar
|
||||
```
|
||||
|
||||
Change `Bundle-Version` whenever the jar changes: OSGi caches bundles by version.
|
||||
|
||||
Бінарний файл не відображається.
@@ -31,8 +31,6 @@ import com.sun.jdi.event.MethodExitEvent;
|
||||
import com.sun.jdi.event.VMDeathEvent;
|
||||
import com.sun.jdi.event.VMDisconnectEvent;
|
||||
import com.sun.jdi.request.EventRequest;
|
||||
import com.sun.jdi.request.EventRequestManager;
|
||||
import com.sun.jdi.request.ExceptionRequest;
|
||||
import com.sun.jdi.request.MethodEntryRequest;
|
||||
import com.sun.jdi.request.MethodExitRequest;
|
||||
import com.sun.jdi.request.StepRequest;
|
||||
@@ -172,10 +170,6 @@ final class RealRunTrace {
|
||||
private Value echoValue;
|
||||
private EventSet parked;
|
||||
private Method terminalMethod;
|
||||
/** Stops the thread at a throw of the terminal's that nothing catches; see {@link #watchUncaught}. */
|
||||
private volatile EventRequest uncaught;
|
||||
/** {@code collect} ran, so the client's step-out ended in a stop of its own; see {@link #dispose}. */
|
||||
private volatile boolean steppedOut;
|
||||
|
||||
private RealRunTrace(long id, VirtualMachine vm, ThreadReference thread, RealRunPlan plan, int budget, long generation) {
|
||||
this.id = id;
|
||||
@@ -520,8 +514,6 @@ final class RealRunTrace {
|
||||
}
|
||||
if (outcome instanceof ObjectReference object) keep(pinned(object));
|
||||
restoreSilencers();
|
||||
// Before the state moves: the client steps out as soon as it sees the trace parked.
|
||||
if (kind.equals("threw")) watchUncaught((ObjectReference) outcome);
|
||||
boolean hold;
|
||||
synchronized (stateLock) {
|
||||
terminalKind = kind;
|
||||
@@ -540,61 +532,10 @@ final class RealRunTrace {
|
||||
if (hold) {
|
||||
parked = set;
|
||||
terminalMethod = method;
|
||||
} else {
|
||||
deleteUncaught();
|
||||
}
|
||||
return hold;
|
||||
}
|
||||
|
||||
/**
|
||||
* Worker, before the trace parks on a terminal that threw. The client's step-out ends in the
|
||||
* program's catch, but an exception nothing catches ends the thread, with no stop left to read the
|
||||
* records in. This request stops the thread at that throw instead: java-debug reports every
|
||||
* exception event as a stop. Not when an enabled request of java-debug's already stops there,
|
||||
* since the throw would then be reported twice.
|
||||
*/
|
||||
private void watchUncaught(ObjectReference exception) {
|
||||
try {
|
||||
EventRequestManager manager = vm.eventRequestManager();
|
||||
ReferenceType type = exception.referenceType();
|
||||
for (ExceptionRequest r : manager.exceptionRequests()) {
|
||||
if (r.isEnabled() && r.notifyUncaught() && r.getProperty(Silencer.OWN_PROPERTY) == null && covers(r.exception(), type)) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
ExceptionRequest r = manager.createExceptionRequest(null, false, true);
|
||||
r.addThreadFilter(thread);
|
||||
r.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD);
|
||||
r.putProperty(Silencer.OWN_PROPERTY, id);
|
||||
r.enable();
|
||||
uncaught = r;
|
||||
} catch (VMDisconnectedException e) {
|
||||
// nothing left to stop
|
||||
} catch (RuntimeException e) {
|
||||
errors.add("watching for an uncaught throw: " + e);
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean covers(ReferenceType declared, ReferenceType type) {
|
||||
for (ReferenceType t = type; t != null; t = t instanceof ClassType c ? c.superclass() : null) {
|
||||
if (declared == null || t.equals(declared)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private void deleteUncaught() {
|
||||
EventRequest r = uncaught;
|
||||
if (r == null) return;
|
||||
uncaught = null;
|
||||
try {
|
||||
vm.eventRequestManager().deleteEventRequest(r);
|
||||
} catch (VMDisconnectedException e) {
|
||||
// it went with the VM
|
||||
} catch (RuntimeException e) {
|
||||
errors.add("deleting the uncaught-throw request: " + e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Worker, right before the terminal's invoke. JDWP holds an interrupt or stop of a thread that is
|
||||
* handling an event until that event's handler exits, and an invoke runs inside the handler of the
|
||||
@@ -817,11 +758,9 @@ final class RealRunTrace {
|
||||
/** Worker: everything the trace holds, a parked thread the client never stepped out included. */
|
||||
private void dispose() {
|
||||
if (parked != null) {
|
||||
// A stop at an uncaught throw of the terminal's keeps the parked frames: resuming would end it behind java-debug.
|
||||
if (!steppedOut && stillParked()) resume(parked);
|
||||
if (stillParked()) resume(parked);
|
||||
parked = null;
|
||||
}
|
||||
deleteUncaught();
|
||||
teardown();
|
||||
for (ObjectReference o : pinned) {
|
||||
try {
|
||||
@@ -1057,8 +996,6 @@ final class RealRunTrace {
|
||||
if (generation <= this.generation) {
|
||||
throw new Failure("stale", "collect needs a stop after the trace's, not generation " + generation);
|
||||
}
|
||||
steppedOut = true;
|
||||
deleteUncaught();
|
||||
handles.begin(generation);
|
||||
ToLongFunction<ObjectReference> handle = o -> {
|
||||
long objectId = o.uniqueID();
|
||||
|
||||
@@ -100,9 +100,6 @@ public class Real {
|
||||
case "inl": inLambda(); break;
|
||||
case "abort": abort(); break;
|
||||
case "twice": abortAfterTrace(); break;
|
||||
case "U": uncaught(true); break;
|
||||
case "Ux": uncaught(false); break;
|
||||
case "Ua": abortUncaught(); break;
|
||||
case "exit": exit(); break;
|
||||
case "mid": mid(); break;
|
||||
case "fn": functionAndData(); break;
|
||||
@@ -247,23 +244,6 @@ public class Real {
|
||||
}
|
||||
}
|
||||
|
||||
/** Keeps the VM alive once main has died of an exception. */
|
||||
static void keeper() {
|
||||
new Thread(() -> LockSupport.parkNanos(60_000_000_000L), "keeper").start();
|
||||
}
|
||||
|
||||
static void uncaught(boolean keep) {
|
||||
if (keep) keeper();
|
||||
List<Integer> u = nums.stream().map(x -> 10 / (x - 4)).collect(Collectors.toList()); // @U
|
||||
System.out.println("U " + u);
|
||||
}
|
||||
|
||||
static void abortUncaught() {
|
||||
keeper();
|
||||
long never = Stream.iterate(1L, x -> x + 1).filter(x -> x < 0).count(); // @Ua
|
||||
System.out.println("UA none " + never);
|
||||
}
|
||||
|
||||
static void exit() {
|
||||
List<Integer> e = nums.stream().filter(x -> { // @exit
|
||||
if (x == 8) System.exit(3);
|
||||
@@ -1045,77 +1025,6 @@ def real_run_abort_after_a_trace():
|
||||
dbg.end()
|
||||
|
||||
|
||||
def uncaught_stop(dbg, name, trace, exception):
|
||||
"""After a terminal that threw what the program does not catch: the step-out ends in one stop at that
|
||||
throw, the records can be read there, and Resume lets the exception end the thread. False when no
|
||||
stop came."""
|
||||
try:
|
||||
stop = step_out(dbg, 15)
|
||||
except (TimeoutError, AssertionError) as e:
|
||||
check(f'{name}: the uncaught throw stops the traced thread', False, repr(e))
|
||||
return False
|
||||
check(f'{name}: the uncaught throw stops the traced thread', stop.get('reason') == 'exception', stop)
|
||||
check(f'{name}: one stop for the throw', no_stop(dbg, 2))
|
||||
c = ok(stream('collect', dbg, traceId=trace))
|
||||
t = c['terminal']
|
||||
check(f'{name}: the terminal threw {exception}', t['kind'] == 'threw' and t['exception'].get('typeName') == exception, t)
|
||||
check(f'{name}: release keeps the stop', 'ok' in stream('release', dbg, traceId=trace) and top(dbg) is not None)
|
||||
resume(dbg)
|
||||
out = output_line(dbg, 'Exception in thread "main" ' + exception)
|
||||
check(f'{name}: the exception ends the thread as without the trace', out is not None, ''.join(dbg.dap.output)[-300:])
|
||||
check(f'{name}: no stop after Resume', no_stop(dbg, 2))
|
||||
return c
|
||||
|
||||
|
||||
@case
|
||||
def real_run_uncaught_throw():
|
||||
# `U` keeps the VM alive with another thread; `Ux` exits with main.
|
||||
for name in ('U', 'Ux'):
|
||||
dbg = real(name, 'U')
|
||||
try:
|
||||
trace, state, _ = run_until_parked(dbg, 'U', steps=(spec('map', 1),), step_kinds=('sync',))
|
||||
check(f'{name}: parked after the lambda threw', state['state'] == 'parked', state)
|
||||
c = uncaught_stop(dbg, name, trace, 'java.lang.ArithmeticException')
|
||||
if c:
|
||||
collected_ok(name, c, records=['0=5', '1=10', '0=3', '1=-10', '0=8', '1=2', '0=1', '1=-3', '0=4'])
|
||||
finally:
|
||||
dbg.end()
|
||||
|
||||
|
||||
@case
|
||||
def real_run_uncaught_throw_user_filter():
|
||||
# java-debug's own uncaught-exception request is on: the throw must stop once, not once per request.
|
||||
dbg = real('U')
|
||||
try:
|
||||
dbg.dap.request('setExceptionBreakpoints', {'filters': ['uncaught']})
|
||||
trace, state, _ = run_until_parked(dbg, 'U', steps=(spec('map', 1),), step_kinds=('sync',))
|
||||
check('U-filter: parked after the lambda threw', state['state'] == 'parked', state)
|
||||
uncaught_stop(dbg, 'U-filter', trace, 'java.lang.ArithmeticException')
|
||||
finally:
|
||||
dbg.end()
|
||||
|
||||
|
||||
@case
|
||||
def real_run_uncaught_abort():
|
||||
dbg = real('Ua')
|
||||
try:
|
||||
trace = ok(arm(dbg, at='Ua', root=spec('iterate', 2), steps=(spec('filter', 1),), terminal=spec('count'),
|
||||
class_filters=('java.util.stream.*',), step_kinds=('sync',)))['traceId']
|
||||
resume(dbg)
|
||||
first = ok(stream('wait', dbg, traceId=trace, ms=500))
|
||||
check('Ua: the endless terminal is running', first['state'] == 'running', first)
|
||||
r = ok(stream('abort', dbg, traceId=trace, timeout=30))
|
||||
check('Ua: interrupted or stopped', r.get('state') in ('interrupted', 'stopped'), r)
|
||||
state = wait_until_done(dbg, trace, 20)
|
||||
check('Ua: parked after the cancel', state['state'] == 'parked', state)
|
||||
if state['state'] == 'parked':
|
||||
c = uncaught_stop(dbg, 'Ua', trace, 'java.lang.RuntimeException')
|
||||
if c:
|
||||
check('Ua: the records up to the abort', len(c['records']) > 0, len(c['records']))
|
||||
finally:
|
||||
dbg.end()
|
||||
|
||||
|
||||
def next_breakpoint_stops(dbg, name, what):
|
||||
"""After a trace that ended without parking: the user's breakpoints are back on."""
|
||||
try:
|
||||
|
||||
@@ -17,7 +17,7 @@ func main() {
|
||||
[[language-servers]]
|
||||
name = "gopls"
|
||||
command = "gopls"
|
||||
initialization-options = { semanticTokens = true, vulncheck = "Imports", hints = { constantValues = true } }
|
||||
initialization-options = { semanticTokens = true, vulncheck = "Imports" }
|
||||
root-markers = ["go.work", "go.mod"]
|
||||
install-hint = "go install golang.org/x/tools/gopls@latest"
|
||||
|
||||
|
||||
@@ -26,8 +26,6 @@ adapter = "java-debug"
|
||||
command = "com.microsoft.java.debug.plugin.jar"
|
||||
transport = "tcp"
|
||||
install-hint = "Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers › Java Debugger)"
|
||||
# Its lazy values are toString() of objects whose class overrides it.
|
||||
resolve-lazy-variables = true
|
||||
|
||||
[[language-servers]]
|
||||
name = "jdtls"
|
||||
|
||||
@@ -1,56 +0,0 @@
|
||||
diff --git a/dist/index.cjs b/dist/index.cjs
|
||||
index 4172cb0f2befc00da9ae09eb3486cae743403a97..ed3c542377fc6dff0195dd9116c16464fb615919 100644
|
||||
--- a/dist/index.cjs
|
||||
+++ b/dist/index.cjs
|
||||
@@ -208,7 +208,9 @@ class Stack {
|
||||
if (index > 0 && (this.buffer[index - 4] != 0 /* Term.Err */ || this.buffer[index - 1] < 0)) {
|
||||
let mustMove = false;
|
||||
for (let scan = index; scan > 0 && this.buffer[scan - 2] > end; scan -= 4) {
|
||||
- if (this.buffer[scan - 1] >= 0) {
|
||||
+ // Reused skipped nodes after the end must be moved out too.
|
||||
+ if (this.buffer[scan - 1] >= 0 ||
|
||||
+ this.buffer[scan - 1] == -1 && this.p.reused[this.buffer[scan - 4]].type.isSkipped) {
|
||||
mustMove = true;
|
||||
break;
|
||||
}
|
||||
@@ -278,7 +280,11 @@ class Stack {
|
||||
this.p.reused.push(value);
|
||||
index++;
|
||||
}
|
||||
- let end = this.reducePos = this.pos = start + value.length;
|
||||
+ // A reused skipped node (a comment) is not part of the node being
|
||||
+ // reduced: like a shifted skipped token, it leaves reducePos alone.
|
||||
+ let end = this.pos = start + value.length;
|
||||
+ if (!value.type.isSkipped)
|
||||
+ this.reducePos = end;
|
||||
this.pushState(next, start);
|
||||
this.buffer.push(index, start, end, -1 /* size == -1 means this is a reused value */);
|
||||
if (this.curContext)
|
||||
diff --git a/dist/index.js b/dist/index.js
|
||||
index 8fd3f87829c312b93ce022867fd17bf34da0dbc0..f67b16d2f46d683f12ddc81534efbf50925e7c65 100644
|
||||
--- a/dist/index.js
|
||||
+++ b/dist/index.js
|
||||
@@ -206,7 +206,9 @@ class Stack {
|
||||
if (index > 0 && (this.buffer[index - 4] != 0 /* Term.Err */ || this.buffer[index - 1] < 0)) {
|
||||
let mustMove = false;
|
||||
for (let scan = index; scan > 0 && this.buffer[scan - 2] > end; scan -= 4) {
|
||||
- if (this.buffer[scan - 1] >= 0) {
|
||||
+ // Reused skipped nodes after the end must be moved out too.
|
||||
+ if (this.buffer[scan - 1] >= 0 ||
|
||||
+ this.buffer[scan - 1] == -1 && this.p.reused[this.buffer[scan - 4]].type.isSkipped) {
|
||||
mustMove = true;
|
||||
break;
|
||||
}
|
||||
@@ -276,7 +278,11 @@ class Stack {
|
||||
this.p.reused.push(value);
|
||||
index++;
|
||||
}
|
||||
- let end = this.reducePos = this.pos = start + value.length;
|
||||
+ // A reused skipped node (a comment) is not part of the node being
|
||||
+ // reduced: like a shifted skipped token, it leaves reducePos alone.
|
||||
+ let end = this.pos = start + value.length;
|
||||
+ if (!value.type.isSkipped)
|
||||
+ this.reducePos = end;
|
||||
this.pushState(next, start);
|
||||
this.buffer.push(index, start, end, -1 /* size == -1 means this is a reused value */);
|
||||
if (this.curContext)
|
||||
Створено
+26
-27
@@ -9,7 +9,6 @@ overrides:
|
||||
|
||||
patchedDependencies:
|
||||
'@codemirror/view': 0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5
|
||||
'@lezer/lr': 1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8
|
||||
|
||||
importers:
|
||||
|
||||
@@ -83,7 +82,7 @@ importers:
|
||||
version: 1.2.5
|
||||
'@lezer/lr':
|
||||
specifier: ^1.4.11
|
||||
version: 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
version: 1.4.11
|
||||
'@plutojl/lang-julia':
|
||||
specifier: ^1.2.0
|
||||
version: 1.2.0
|
||||
@@ -2409,7 +2408,7 @@ snapshots:
|
||||
'@codemirror/language': 6.13.1
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2468,7 +2467,7 @@ snapshots:
|
||||
'@codemirror/view': 6.43.14(patch_hash=0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5)
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2481,7 +2480,7 @@ snapshots:
|
||||
'@codemirror/language': 6.13.1
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2492,7 +2491,7 @@ snapshots:
|
||||
'@codemirror/view': 6.43.14(patch_hash=0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5)
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2540,7 +2539,7 @@ snapshots:
|
||||
'@codemirror/state': 6.7.6
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2549,14 +2548,14 @@ snapshots:
|
||||
'@codemirror/language': 6.13.1
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
'@codemirror/language': 6.13.1
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2574,7 +2573,7 @@ snapshots:
|
||||
'@codemirror/state': 6.7.6
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/yaml': 1.0.4
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
@@ -2610,7 +2609,7 @@ snapshots:
|
||||
'@codemirror/view': 6.43.14(patch_hash=0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5)
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
style-mod: 4.1.4
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
@@ -2746,24 +2745,24 @@ snapshots:
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
@@ -2773,27 +2772,27 @@ snapshots:
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@lezer/[email protected](patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)':
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
|
||||
@@ -2806,37 +2805,37 @@ snapshots:
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@marijn/[email protected]': {}
|
||||
|
||||
@@ -3102,7 +3101,7 @@ snapshots:
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/lr': 1.4.11
|
||||
|
||||
'@replit/[email protected]': {}
|
||||
|
||||
|
||||
@@ -5,4 +5,3 @@ overrides:
|
||||
mermaid>katex: ^0.18.2
|
||||
patchedDependencies:
|
||||
"@codemirror/view": patches/@codemirror__view.patch
|
||||
"@lezer/lr": patches/@lezer__lr.patch
|
||||
@@ -41,7 +41,6 @@ ide-core.workspace = true
|
||||
ide-cli.workspace = true
|
||||
dunce.workspace = true
|
||||
ide-clipboard.workspace = true
|
||||
ide-drag-out.workspace = true
|
||||
ide-fonts.workspace = true
|
||||
ide-text.workspace = true
|
||||
ide-vfs.workspace = true
|
||||
|
||||
@@ -1,8 +1,7 @@
|
||||
//! Native drags started from the web UI: the window from its title bar, files out to other apps.
|
||||
//! Native window drag started from the web title bar.
|
||||
|
||||
use ide_command::desktop_command;
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use std::path::PathBuf;
|
||||
use tauri::WebviewWindow;
|
||||
|
||||
/// Starts dragging `window` while the primary mouse button is still down; returns whether a drag began.
|
||||
@@ -21,41 +20,4 @@ pub fn window_start_drag(window: WebviewWindow) -> IdeResult<bool> {
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
/// Drags `paths` (local files and folders) out of `window` while the primary mouse button is
|
||||
/// still down, so the app they are dropped on copies them (#2867). Resolves when the drag ends,
|
||||
/// with whether a target took the files.
|
||||
#[desktop_command(trust = always)]
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub async fn window_drag_files(window: WebviewWindow, paths: Vec<PathBuf>) -> IdeResult<bool> {
|
||||
let paths = ide_drag_out::local_paths(paths)?;
|
||||
let (started_tx, started_rx) = tokio::sync::oneshot::channel();
|
||||
let (done_tx, done_rx) = tokio::sync::oneshot::channel();
|
||||
let source = window.clone();
|
||||
window
|
||||
.run_on_main_thread(move || {
|
||||
let done = move |outcome| {
|
||||
let _ = done_tx.send(outcome);
|
||||
};
|
||||
// A tap WebKit delivered late: nothing is held, so the drag would never end.
|
||||
#[cfg(target_os = "macos")]
|
||||
if objc2_app_kit::NSEvent::pressedMouseButtons() & 1 == 0 {
|
||||
let _ = started_tx.send(Ok(()));
|
||||
return;
|
||||
}
|
||||
#[cfg(target_os = "linux")]
|
||||
let started = source
|
||||
.gtk_window()
|
||||
.map_err(|error| std::io::Error::other(error.to_string()))
|
||||
.and_then(|gtk_window| ide_drag_out::start(>k_window, paths, done));
|
||||
#[cfg(any(windows, target_os = "macos"))]
|
||||
let started = ide_drag_out::start(&source, paths, done);
|
||||
let _ = started_tx.send(started);
|
||||
})
|
||||
.map_err(|error| IdeError::internal(format!("Cannot start a drag on the main thread: {error}")))?;
|
||||
started_rx.await.map_err(|error| IdeError::internal(error.to_string()))??;
|
||||
// Dropped without an outcome when the drag never began or its backend lost it.
|
||||
Ok(matches!(done_rx.await, Ok(ide_drag_out::Outcome::Dropped)))
|
||||
}
|
||||
|
||||
ide_command::desktop_domain!(window_start_drag, window_drag_files);
|
||||
ide_command::desktop_domain!(window_start_drag);
|
||||
@@ -1,8 +1,4 @@
|
||||
use ide_core::{EventSink, IdeEvent, SharedSink};
|
||||
use parking_lot::Mutex;
|
||||
use std::collections::{HashMap, VecDeque};
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use ide_core::{EventSink, IdeEvent};
|
||||
use tauri::{AppHandle, Emitter, Manager, UserAttentionType};
|
||||
|
||||
/// Name of the single backend → UI event. Payload: [`IdeEvent`].
|
||||
@@ -42,103 +38,6 @@ pub struct TauriSink {
|
||||
pub window: Option<String>,
|
||||
}
|
||||
|
||||
const COALESCE_WINDOW: Duration = Duration::from_millis(16);
|
||||
const MAX_PENDING_DIAGNOSTICS: usize = 4096;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
||||
struct DiagnosticKey {
|
||||
path: ide_core::IpcPath,
|
||||
source: String,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct PendingDiagnostics {
|
||||
order: VecDeque<DiagnosticKey>,
|
||||
events: HashMap<DiagnosticKey, IdeEvent>,
|
||||
scheduled: bool,
|
||||
}
|
||||
|
||||
fn diagnostic_key(event: &IdeEvent) -> Option<DiagnosticKey> {
|
||||
let IdeEvent::Diagnostics { path, source, .. } = event else {
|
||||
return None;
|
||||
};
|
||||
Some(DiagnosticKey { path: path.clone(), source: source.clone() })
|
||||
}
|
||||
|
||||
fn take_pending(state: &mut PendingDiagnostics) -> Vec<IdeEvent> {
|
||||
let mut events = Vec::with_capacity(state.events.len());
|
||||
for key in state.order.drain(..) {
|
||||
if let Some(event) = state.events.remove(&key) {
|
||||
events.push(event);
|
||||
}
|
||||
}
|
||||
events
|
||||
}
|
||||
|
||||
/// Collapses repeated full-replacement diagnostics for one `(path, source)` into the
|
||||
/// latest event in a frame-sized window. Any other event flushes the pending
|
||||
/// diagnostics first so lifecycle and ordered events cannot overtake them.
|
||||
pub fn coalescing_sink(sink: SharedSink, runtime: tokio::runtime::Handle) -> SharedSink {
|
||||
let pending = Arc::new(Mutex::new(PendingDiagnostics::default()));
|
||||
let dispatch = Arc::new(Mutex::new(()));
|
||||
Arc::new(move |event| {
|
||||
let Some(key) = diagnostic_key(&event) else {
|
||||
let _dispatch = dispatch.lock();
|
||||
let events = take_pending(&mut pending.lock());
|
||||
for pending_event in events {
|
||||
sink.emit(pending_event);
|
||||
}
|
||||
sink.emit(event);
|
||||
return;
|
||||
};
|
||||
|
||||
loop {
|
||||
let schedule = {
|
||||
let mut state = pending.lock();
|
||||
if !state.events.contains_key(&key) && state.events.len() >= MAX_PENDING_DIAGNOSTICS {
|
||||
None
|
||||
} else {
|
||||
if !state.events.contains_key(&key) {
|
||||
state.order.push_back(key.clone());
|
||||
}
|
||||
state.events.insert(key.clone(), event.clone());
|
||||
if state.scheduled {
|
||||
return;
|
||||
}
|
||||
state.scheduled = true;
|
||||
Some(())
|
||||
}
|
||||
};
|
||||
|
||||
if schedule.is_none() {
|
||||
let _dispatch = dispatch.lock();
|
||||
let events = take_pending(&mut pending.lock());
|
||||
for pending_event in events {
|
||||
sink.emit(pending_event);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
let pending = pending.clone();
|
||||
let dispatch = dispatch.clone();
|
||||
let sink = sink.clone();
|
||||
runtime.spawn(async move {
|
||||
tokio::time::sleep(COALESCE_WINDOW).await;
|
||||
let _dispatch = dispatch.lock();
|
||||
let events = {
|
||||
let mut state = pending.lock();
|
||||
state.scheduled = false;
|
||||
take_pending(&mut state)
|
||||
};
|
||||
for event in events {
|
||||
sink.emit(event);
|
||||
}
|
||||
});
|
||||
return;
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// A debug session stopped on a breakpoint: bounce/flash the taskbar icon
|
||||
/// (IDEA) unless the user is already looking at an OpenIDEA window. The focus
|
||||
/// check and the request both touch the windowing system, so they run on the
|
||||
@@ -195,205 +94,3 @@ impl EventSink for TauriSink {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use ide_core::{Diagnostic, IpcPath, Pos, Range, Severity, TaskId};
|
||||
use parking_lot::Mutex;
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::time::Duration;
|
||||
use std::time::Instant;
|
||||
|
||||
fn setup() -> (ide_core::SharedSink, Arc<Mutex<Vec<IdeEvent>>>) {
|
||||
let events = Arc::new(Mutex::new(Vec::new()));
|
||||
let saved = events.clone();
|
||||
(coalescing_sink(Arc::new(move |event| saved.lock().push(event)), tokio::runtime::Handle::current()), events)
|
||||
}
|
||||
|
||||
fn diagnostics(path: &str, source: &str, message: &str) -> IdeEvent {
|
||||
IdeEvent::Diagnostics {
|
||||
path: IpcPath::from(path),
|
||||
source: source.into(),
|
||||
items: vec![Diagnostic {
|
||||
range: Range::point(Pos::new(0, 0)),
|
||||
severity: Severity::Error,
|
||||
message: message.into(),
|
||||
source: None,
|
||||
code: None,
|
||||
unnecessary: false,
|
||||
deprecated: false,
|
||||
server: None,
|
||||
}],
|
||||
}
|
||||
}
|
||||
|
||||
fn task(message: &str, done: bool) -> IdeEvent {
|
||||
IdeEvent::Task {
|
||||
id: TaskId(1),
|
||||
title: "Indexing".into(),
|
||||
message: Some(message.into()),
|
||||
fraction: Some(if done { 1.0 } else { 0.5 }),
|
||||
done,
|
||||
cancellable: !done,
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn coalesces_diagnostics_by_path_and_source() {
|
||||
let (sink, events) = setup();
|
||||
for index in 0..100 {
|
||||
sink.emit(diagnostics("/p/a.rs", "rust-analyzer", &format!("old {index}")));
|
||||
}
|
||||
sink.emit(diagnostics("/p/a.rs", "eslint", "lint"));
|
||||
sink.emit(diagnostics("/p/b.rs", "rust-analyzer", "other"));
|
||||
|
||||
assert!(events.lock().is_empty());
|
||||
tokio::task::yield_now().await;
|
||||
tokio::time::sleep(Duration::from_millis(30)).await;
|
||||
tokio::task::yield_now().await;
|
||||
|
||||
{
|
||||
let saved_events = events.lock();
|
||||
assert_eq!(saved_events.len(), 3);
|
||||
assert!(matches!(
|
||||
&saved_events[0],
|
||||
IdeEvent::Diagnostics { path, source, items }
|
||||
if path == &IpcPath::from("/p/a.rs")
|
||||
&& source == "rust-analyzer"
|
||||
&& items[0].message == "old 99"
|
||||
));
|
||||
assert!(matches!(
|
||||
&saved_events[1],
|
||||
IdeEvent::Diagnostics { path, source, .. }
|
||||
if path == &IpcPath::from("/p/a.rs") && source == "eslint"
|
||||
));
|
||||
assert!(matches!(
|
||||
&saved_events[2],
|
||||
IdeEvent::Diagnostics { path, source, .. }
|
||||
if path == &IpcPath::from("/p/b.rs") && source == "rust-analyzer"
|
||||
));
|
||||
}
|
||||
|
||||
tokio::time::sleep(Duration::from_millis(30)).await;
|
||||
assert_eq!(events.lock().len(), 3);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn immediate_events_flush_pending_events_first() {
|
||||
let (sink, events) = setup();
|
||||
sink.emit(diagnostics("/p/a.rs", "rust-analyzer", "before"));
|
||||
sink.emit(diagnostics("/p/b.rs", "rust-analyzer", "other"));
|
||||
sink.emit(IdeEvent::SettingsChanged { key: "editor.fontSize".into() });
|
||||
|
||||
let events = events.lock();
|
||||
assert_eq!(events.len(), 3);
|
||||
assert!(matches!(&events[0], IdeEvent::Diagnostics { .. }));
|
||||
assert!(matches!(&events[1], IdeEvent::Diagnostics { .. }));
|
||||
assert!(matches!(&events[2], IdeEvent::SettingsChanged { .. }));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn lifecycle_events_remain_immediate() {
|
||||
let (sink, events) = setup();
|
||||
sink.emit(task("complete", true));
|
||||
let events = events.lock();
|
||||
assert_eq!(events.len(), 1);
|
||||
assert!(matches!(
|
||||
&events[0],
|
||||
IdeEvent::Task { message, done, .. }
|
||||
if message.as_deref() == Some("complete") && *done
|
||||
));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn diagnostic_buffer_cap_flushes_without_dropping() {
|
||||
let (sink, events) = setup();
|
||||
for index in 0..=MAX_PENDING_DIAGNOSTICS {
|
||||
sink.emit(diagnostics(&format!("/p/{index}.rs"), "rust-analyzer", "diagnostic"));
|
||||
}
|
||||
assert_eq!(events.lock().len(), MAX_PENDING_DIAGNOSTICS);
|
||||
|
||||
tokio::time::sleep(Duration::from_millis(30)).await;
|
||||
assert_eq!(events.lock().len(), MAX_PENDING_DIAGNOSTICS + 1);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
#[ignore = "run for before/after diagnostics transport measurements"]
|
||||
async fn diagnostics_coalescing_benchmark() {
|
||||
const FILES: usize = 2_000;
|
||||
const ROUNDS: usize = 10;
|
||||
let burst: Vec<IdeEvent> = (0..ROUNDS)
|
||||
.flat_map(|round| {
|
||||
(0..FILES).map(move |file| {
|
||||
diagnostics(&format!("/workspace/src/File{file}.rs"), "rust-analyzer", &format!("round-{round}"))
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
|
||||
let raw_events = Arc::new(AtomicUsize::new(0));
|
||||
let raw_count = raw_events.clone();
|
||||
let raw: SharedSink = Arc::new(move |event| {
|
||||
let encoded = serde_json::to_vec(&event).unwrap();
|
||||
raw_count.fetch_add(1, Ordering::Relaxed);
|
||||
std::hint::black_box(encoded.len());
|
||||
});
|
||||
let raw_started = Instant::now();
|
||||
for event in &burst {
|
||||
raw.emit(event.clone());
|
||||
}
|
||||
let raw_elapsed = raw_started.elapsed();
|
||||
assert_eq!(raw_events.load(Ordering::Relaxed), FILES * ROUNDS);
|
||||
|
||||
let coalesced_events = Arc::new(AtomicUsize::new(0));
|
||||
let delivered_state = Arc::new(Mutex::new(HashMap::<IpcPath, String>::new()));
|
||||
let coalesced_count = coalesced_events.clone();
|
||||
let delivered = delivered_state.clone();
|
||||
let target: SharedSink = Arc::new(move |event| {
|
||||
let encoded = serde_json::to_vec(&event).unwrap();
|
||||
coalesced_count.fetch_add(1, Ordering::Relaxed);
|
||||
if let IdeEvent::Diagnostics { path, items, .. } = event {
|
||||
delivered.lock().insert(path, items[0].message.clone());
|
||||
}
|
||||
std::hint::black_box(encoded.len());
|
||||
});
|
||||
let coalesced = coalescing_sink(target, tokio::runtime::Handle::current());
|
||||
let coalesced_started = Instant::now();
|
||||
for event in &burst {
|
||||
coalesced.emit(event.clone());
|
||||
}
|
||||
|
||||
let expected_last_round = format!("round-{}", ROUNDS - 1);
|
||||
let deadline = Instant::now() + Duration::from_secs(2);
|
||||
loop {
|
||||
let complete = {
|
||||
let delivered_state = delivered_state.lock();
|
||||
delivered_state.len() == FILES
|
||||
&& delivered_state.values().all(|message| message == &expected_last_round)
|
||||
};
|
||||
if complete {
|
||||
break;
|
||||
}
|
||||
assert!(Instant::now() < deadline, "diagnostics did not settle before benchmark timeout");
|
||||
tokio::time::sleep(Duration::from_millis(5)).await;
|
||||
}
|
||||
let coalesced_elapsed = coalesced_started.elapsed();
|
||||
|
||||
let coalesced_count = coalesced_events.load(Ordering::Relaxed);
|
||||
assert!(coalesced_count >= FILES);
|
||||
assert!(coalesced_count < FILES * ROUNDS);
|
||||
let delivered_state = delivered_state.lock();
|
||||
assert_eq!(delivered_state.len(), FILES);
|
||||
assert!(delivered_state.values().all(|message| message == &expected_last_round));
|
||||
println!(
|
||||
"diagnostics transport burst: raw_events={} raw_ms={:.2} coalesced_events={} \
|
||||
coalesced_total_ms={:.2} reduction_pct={:.1}",
|
||||
FILES * ROUNDS,
|
||||
raw_elapsed.as_secs_f64() * 1_000.0,
|
||||
coalesced_count,
|
||||
coalesced_elapsed.as_secs_f64() * 1_000.0,
|
||||
(1.0 - coalesced_count as f64 / (FILES * ROUNDS) as f64) * 100.0,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -288,12 +288,6 @@ pub fn run() {
|
||||
window_groups::frame_changed(window.app_handle(), window.label());
|
||||
}
|
||||
tauri::WindowEvent::Destroyed => {
|
||||
// Also release a view that failed during startup, before the parent could watch it.
|
||||
if let Some(state) = window.try_state::<AppState>()
|
||||
&& let Ok(project) = state.host.project(window.label())
|
||||
{
|
||||
project.agents.unsubscribe(window.label());
|
||||
}
|
||||
window_zoom::forget(window.label());
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
|
||||
Loaded 100 of 298 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача