дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-21 00:50:47 +02:00
Порівняти коміти
52
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
e091561937 | ||
|
|
423bf2c733 | ||
|
|
73d1470940 | ||
|
|
c83b0b1442 | ||
|
|
d16993e175 | ||
|
|
5d4cdac3c7 | ||
|
|
9c414cc75c | ||
|
|
3bbc90d750 | ||
|
|
6d157c8b71 | ||
|
|
f2c0fcdc96 | ||
|
|
a4574fdc92 | ||
|
|
4bc87f5d84 | ||
|
|
39671ff55b | ||
|
|
881812547d | ||
|
|
9c145ea258 | ||
|
|
4f192a12bc | ||
|
|
1d857375dc | ||
|
|
6543cdb36b | ||
|
|
684c92ce90 | ||
|
|
9a77a95180 | ||
|
|
1000ef0fa0 | ||
|
|
654da3e1ef | ||
|
|
ba6ccaf9b2 | ||
|
|
3ec631f0c0 | ||
|
|
f64796607c | ||
|
|
5baaf5b7de | ||
|
|
95f88f6ffb | ||
|
|
06b7c3a826 | ||
|
|
e9335f032d | ||
|
|
d09fdc8c7e | ||
|
|
54e69973c8 | ||
|
|
91d37aa4bf | ||
|
|
e149ba2ab3 | ||
|
|
fc6de7d0e4 | ||
|
|
76ef8c9b05 | ||
|
|
0344553652 | ||
|
|
cf15013b49 | ||
|
|
eb985cda28 | ||
|
|
212ee03d71 | ||
|
|
b721fe09db | ||
|
|
6ffb4c22f0 | ||
|
|
dc38b0b081 | ||
|
|
3cbc9d7f75 | ||
|
|
2ec2a6c262 | ||
|
|
11dca3ab42 | ||
|
|
f9044dcc00 | ||
|
|
a7d7293b2f | ||
|
|
a5280c50f7 | ||
|
|
dd0578979a | ||
|
|
e96b0483ac | ||
|
|
608b292510 | ||
|
|
dd6d83fd2c |
No files matched your search
Створено
+17
@@ -4156,6 +4156,8 @@ dependencies = [
|
||||
"ide-vcs",
|
||||
"ide-vfs",
|
||||
"parking_lot",
|
||||
"rustix",
|
||||
"semver",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"specta",
|
||||
@@ -4357,6 +4359,20 @@ dependencies = [
|
||||
"which",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-drag-out"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"gtk",
|
||||
"objc2 0.6.5",
|
||||
"objc2-app-kit 0.3.2",
|
||||
"objc2-foundation 0.3.2",
|
||||
"raw-window-handle",
|
||||
"tempfile",
|
||||
"windows",
|
||||
"windows-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-extension"
|
||||
version = "0.1.49"
|
||||
@@ -6698,6 +6714,7 @@ dependencies = [
|
||||
"ide-dap",
|
||||
"ide-db",
|
||||
"ide-docker",
|
||||
"ide-drag-out",
|
||||
"ide-extension",
|
||||
"ide-fonts",
|
||||
"ide-github",
|
||||
|
||||
@@ -38,6 +38,7 @@ ide-web = { path = "crates/ide-web" }
|
||||
ide-spell = { path = "crates/ide-spell" }
|
||||
ide-agent = { path = "crates/ide-agent" }
|
||||
ide-clipboard = { path = "crates/ide-clipboard" }
|
||||
ide-drag-out = { path = "crates/ide-drag-out" }
|
||||
ide-fonts = { path = "crates/ide-fonts" }
|
||||
ide-ssh = { path = "crates/ide-ssh" }
|
||||
ide-remote = { path = "crates/ide-remote" }
|
||||
|
||||
@@ -25,6 +25,10 @@ dunce.workspace = true
|
||||
uuid.workspace = true
|
||||
tempfile.workspace = true
|
||||
which = "8"
|
||||
semver = "1"
|
||||
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
rustix = { version = "1", features = ["fs"] }
|
||||
|
||||
[dev-dependencies]
|
||||
tokio = { workspace = true, features = ["test-util"] }
|
||||
@@ -0,0 +1,395 @@
|
||||
//! Checks and updates only the global npm installation selected by the agent launcher.
|
||||
use crate::{AgentManager, AgentSource, provider};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, error::ErrorKind};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
use specta::Type;
|
||||
use std::{
|
||||
fs, io,
|
||||
path::{Path, PathBuf},
|
||||
process::Command,
|
||||
};
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
pub struct AgentCliOffer {
|
||||
pub current: String,
|
||||
pub latest: String,
|
||||
pub prefix: PathBuf,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "status", rename_all = "camelCase")]
|
||||
pub enum AgentCliUpdateResult {
|
||||
Available(AgentCliOffer),
|
||||
Permission(AgentCliOffer),
|
||||
Current { current: String },
|
||||
Channel { current: String },
|
||||
Updated { current: String },
|
||||
Unmanaged,
|
||||
Error { code: String },
|
||||
}
|
||||
|
||||
pub(crate) fn package(id: &str) -> Option<&'static str> {
|
||||
Some(match id {
|
||||
"claude" => "@anthropic-ai/claude-code",
|
||||
"codex" => "@openai/codex",
|
||||
"gemini" => "@google/gemini-cli",
|
||||
"opencode" => "opencode-ai",
|
||||
"copilot" => "@github/copilot",
|
||||
"qwen" => "@qwen-code/qwen-code",
|
||||
"auggie" => "@augmentcode/auggie",
|
||||
"qoder" => "@qoder-ai/qodercli",
|
||||
"omp" => "@oh-my-pi/pi-coding-agent",
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
impl AgentManager {
|
||||
pub fn cli_update(
|
||||
&self,
|
||||
id: &str,
|
||||
offer: Option<&AgentCliOffer>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
let spec = self.shared.spec(id).ok_or_else(|| IdeError::invalid(format!("unknown agent {id}")))?;
|
||||
let (Some(pkg), Some(builtin)) = (package(id), provider::builtin_spec(id)) else {
|
||||
return Ok(AgentCliUpdateResult::Unmanaged);
|
||||
};
|
||||
if spec.source != AgentSource::Builtin {
|
||||
return Ok(AgentCliUpdateResult::Unmanaged);
|
||||
}
|
||||
let Ok(npm) = which::which("npm") else { return Ok(AgentCliUpdateResult::Unmanaged) };
|
||||
let program = spec.resolve_for_launch(&self.shared.paths.project_root).command;
|
||||
match maintain(&npm, Path::new(&program), &builtin.command, pkg, offer, cancel) {
|
||||
Err(e) if e.kind == ErrorKind::Unavailable => Ok(AgentCliUpdateResult::Error { code: e.message }),
|
||||
result => result,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct Installation {
|
||||
modules: PathBuf,
|
||||
folder: PathBuf,
|
||||
link: PathBuf,
|
||||
}
|
||||
|
||||
impl Installation {
|
||||
fn at(prefix: &Path, pkg: &str, bin: &str) -> Self {
|
||||
let modules = prefix.join(if cfg!(windows) { "node_modules" } else { "lib/node_modules" });
|
||||
let link = if cfg!(windows) { prefix.join(format!("{bin}.cmd")) } else { prefix.join("bin").join(bin) };
|
||||
Self { folder: modules.join(pkg), modules, link }
|
||||
}
|
||||
|
||||
fn version(&self, program: &Path, pkg: &str, bin: &str) -> IdeResult<Option<String>> {
|
||||
if !program.is_absolute() || !self.folder.try_exists()? || !self.link.try_exists()? || !program.try_exists()? {
|
||||
return Ok(None);
|
||||
}
|
||||
let folder = dunce::canonicalize(&self.folder)?;
|
||||
if fs::symlink_metadata(&self.folder)?.is_symlink()
|
||||
|| dunce::canonicalize(program)? != dunce::canonicalize(&self.link)?
|
||||
{
|
||||
return Ok(None);
|
||||
}
|
||||
let manifest = self.folder.join("package.json");
|
||||
if !manifest.try_exists()? {
|
||||
return Ok(None);
|
||||
}
|
||||
let manifest: Value = serde_json::from_slice(&fs::read(manifest)?)
|
||||
.map_err(|_| IdeError::invalid("Invalid npm package manifest"))?;
|
||||
let entry = manifest["bin"].as_str().or_else(|| manifest["bin"][bin].as_str());
|
||||
let Some(entry) = entry.filter(|_| manifest["name"] == pkg) else { return Ok(None) };
|
||||
let Some(version) = manifest["version"].as_str() else {
|
||||
return Err(IdeError::invalid("Missing npm package version"));
|
||||
};
|
||||
let entry = folder.join(entry);
|
||||
if !entry.try_exists()? {
|
||||
return Ok(None);
|
||||
}
|
||||
let entry = dunce::canonicalize(entry)?;
|
||||
if !entry.starts_with(&folder) {
|
||||
return Ok(None);
|
||||
}
|
||||
#[cfg(unix)]
|
||||
let owns = fs::symlink_metadata(&self.link)?.is_symlink() && dunce::canonicalize(&self.link)? == entry;
|
||||
#[cfg(windows)]
|
||||
let owns = {
|
||||
let prefix = dunce::canonicalize(self.link.parent().unwrap())?;
|
||||
let Ok(target) = entry.strip_prefix(prefix) else { return Ok(None) };
|
||||
let needle = format!("%dp0%\\{}\"", target.display()).to_lowercase();
|
||||
fs::read_to_string(&self.link)?.replace('/', "\\").to_lowercase().contains(&needle)
|
||||
};
|
||||
Ok(owns.then(|| version.to_owned()))
|
||||
}
|
||||
|
||||
fn writable(&self) -> io::Result<bool> {
|
||||
for dir in [&*self.folder, self.folder.parent().unwrap(), &self.modules, self.link.parent().unwrap()] {
|
||||
#[cfg(unix)]
|
||||
let access: io::Result<()> =
|
||||
rustix::fs::accessat(rustix::fs::CWD, dir, rustix::fs::Access::WRITE_OK, rustix::fs::AtFlags::empty())
|
||||
.map_err(Into::into);
|
||||
#[cfg(windows)]
|
||||
let access = tempfile::tempfile_in(dir).map(drop);
|
||||
match access {
|
||||
Err(e) if matches!(e.kind(), io::ErrorKind::PermissionDenied | io::ErrorKind::ReadOnlyFilesystem) => {
|
||||
return Ok(false);
|
||||
}
|
||||
other => other?,
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
fn stable(version: &str) -> Option<semver::Version> {
|
||||
semver::Version::parse(version).ok().filter(|v| v.pre.is_empty() && v.build.is_empty())
|
||||
}
|
||||
|
||||
fn maintain(
|
||||
npm: &Path,
|
||||
program: &Path,
|
||||
bin: &str,
|
||||
pkg: &str,
|
||||
approved: Option<&AgentCliOffer>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
use AgentCliUpdateResult::*;
|
||||
let run = |args: &[&str]| {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let mut cmd = Command::new(npm);
|
||||
cmd.args(args)
|
||||
.current_dir(npm.parent().unwrap())
|
||||
.env("NPM_CONFIG_UPDATE_NOTIFIER", "false")
|
||||
.env("NPM_CONFIG_LOGLEVEL", "error");
|
||||
ide_tools::run_streamed(cmd, cancel, &|_| {}).map_err(|e| {
|
||||
if e.kind == ErrorKind::Cancelled {
|
||||
return e;
|
||||
}
|
||||
// npm diagnostics can contain private registry URLs; expose only known codes.
|
||||
let code = e
|
||||
.message
|
||||
.split(|c: char| !c.is_ascii_alphanumeric() && c != '_')
|
||||
.find(|w| {
|
||||
matches!(
|
||||
*w,
|
||||
"EACCES"
|
||||
| "EPERM"
|
||||
| "EROFS"
|
||||
| "ENOTFOUND"
|
||||
| "EAI_AGAIN"
|
||||
| "ETIMEDOUT"
|
||||
| "E404"
|
||||
| "E401"
|
||||
| "E403"
|
||||
)
|
||||
})
|
||||
.unwrap_or("npm");
|
||||
IdeError::unavailable(code)
|
||||
})
|
||||
};
|
||||
let output = run(&["prefix", "-g"])?;
|
||||
let prefix = Path::new(output.trim_end());
|
||||
if !prefix.is_absolute() {
|
||||
return Err(IdeError::invalid("Invalid npm global prefix"));
|
||||
}
|
||||
let installation = Installation::at(prefix, pkg, bin);
|
||||
let Some(current) = installation.version(program, pkg, bin)? else { return Ok(Unmanaged) };
|
||||
let latest: String = serde_json::from_str(&run(&["view", &format!("{pkg}@latest"), "version", "--json"])?)
|
||||
.map_err(|_| IdeError::invalid("Invalid npm version response"))?;
|
||||
let (Some(before), Some(after)) = (stable(¤t), stable(&latest)) else {
|
||||
return Ok(Channel { current });
|
||||
};
|
||||
if before >= after {
|
||||
return Ok(Current { current });
|
||||
}
|
||||
let offer = AgentCliOffer { current, latest, prefix: prefix.to_owned() };
|
||||
if !installation.writable()? {
|
||||
return Ok(Permission(offer));
|
||||
}
|
||||
if approved != Some(&offer) {
|
||||
return Ok(Available(offer));
|
||||
}
|
||||
run(&[
|
||||
"install",
|
||||
"-g",
|
||||
"--prefix",
|
||||
prefix.to_str().unwrap(),
|
||||
"--no-audit",
|
||||
"--no-fund",
|
||||
&format!("{pkg}@{}", offer.latest),
|
||||
])?;
|
||||
if installation.version(program, pkg, bin)?.as_ref() != Some(&offer.latest) {
|
||||
return Err(IdeError::invalid("npm installation verification failed"));
|
||||
}
|
||||
Ok(Updated { current: offer.latest })
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
use tempfile::TempDir;
|
||||
|
||||
const PKG: &str = "@anthropic-ai/claude-code";
|
||||
|
||||
struct Fixture {
|
||||
root: TempDir,
|
||||
install: Installation,
|
||||
}
|
||||
|
||||
impl Fixture {
|
||||
fn new() -> Self {
|
||||
let root = tempfile::Builder::new().prefix("全局 prefix ").tempdir().unwrap();
|
||||
let install = Installation::at(root.path(), PKG, "claude");
|
||||
fs::create_dir_all(&install.folder).unwrap();
|
||||
fs::create_dir_all(install.link.parent().unwrap()).unwrap();
|
||||
fs::write(install.folder.join("entry.js"), "").unwrap();
|
||||
#[cfg(unix)]
|
||||
std::os::unix::fs::symlink(install.folder.join("entry.js"), &install.link).unwrap();
|
||||
#[cfg(windows)]
|
||||
fs::write(&install.link, r#"@"%dp0%\node_modules\@anthropic-ai\claude-code\entry.js""#).unwrap();
|
||||
let fixture = Self { root, install };
|
||||
fixture.manifest(PKG, "2.1.9");
|
||||
fixture
|
||||
}
|
||||
|
||||
fn manifest(&self, name: &str, version: &str) {
|
||||
fs::write(
|
||||
self.install.folder.join("package.json"),
|
||||
json!({"name":name,"version":version,"bin":{"claude":"entry.js"}}).to_string(),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
fn version(&self) -> Option<String> {
|
||||
self.install.version(&self.install.link, PKG, "claude").unwrap()
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn npm(&self, script: &str) -> PathBuf {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let path = self.root.path().join("npm");
|
||||
fs::write(&path, format!("#!/bin/sh\nset -eu\n{script}\n")).unwrap();
|
||||
fs::set_permissions(&path, fs::Permissions::from_mode(0o755)).unwrap();
|
||||
path
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn requires_the_selected_install_and_its_exact_package_entry() {
|
||||
let f = Fixture::new();
|
||||
assert_eq!(f.version().as_deref(), Some("2.1.9"));
|
||||
let other = f.root.path().join("other");
|
||||
fs::write(&other, "").unwrap();
|
||||
assert_eq!(f.install.version(&other, PKG, "claude").unwrap(), None);
|
||||
f.manifest("other-package", "2.1.9");
|
||||
assert_eq!(f.version(), None);
|
||||
f.manifest(PKG, "2.1.9");
|
||||
fs::remove_file(&f.install.link).unwrap();
|
||||
#[cfg(unix)]
|
||||
std::os::unix::fs::symlink(&other, &f.install.link).unwrap();
|
||||
#[cfg(windows)]
|
||||
fs::write(&f.install.link, r#"@"%dp0%\other""#).unwrap();
|
||||
assert_eq!(f.version(), None);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
const NPM: &str = r#"case "$1" in
|
||||
prefix) pwd -P ;;
|
||||
view) cat latest ;;
|
||||
install)
|
||||
test "$2" = "-g" && test "$3" = "--prefix" && test "$4" = "$(pwd -P)"
|
||||
test "$7" = "@anthropic-ai/[email protected]"
|
||||
cp updated.json "$4/lib/node_modules/@anthropic-ai/claude-code/package.json"
|
||||
touch installed ;;
|
||||
*) exit 2 ;;
|
||||
esac"#;
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn installs_only_the_confirmed_offer_and_rechecks_ownership() {
|
||||
use AgentCliUpdateResult::*;
|
||||
let f = Fixture::new();
|
||||
let npm = f.npm(NPM);
|
||||
let cancel = CancellationToken::new();
|
||||
let run =
|
||||
|offer: Option<&AgentCliOffer>| maintain(&npm, &f.install.link, "claude", PKG, offer, &cancel).unwrap();
|
||||
let latest = f.root.path().join("latest");
|
||||
fs::write(&latest, r#""2.1.12""#).unwrap();
|
||||
let Available(offer) = run(None) else { panic!("expected an offer") };
|
||||
for different in [
|
||||
AgentCliOffer { prefix: PathBuf::from("/other"), ..offer.clone() },
|
||||
AgentCliOffer { current: "2.0.0".into(), ..offer.clone() },
|
||||
] {
|
||||
assert_eq!(run(Some(&different)), Available(offer.clone()));
|
||||
}
|
||||
fs::write(&latest, r#""2.2.0""#).unwrap();
|
||||
assert!(matches!(run(Some(&offer)), Available(new) if new.latest == "2.2.0"));
|
||||
fs::write(&latest, r#""2.0.0""#).unwrap();
|
||||
assert!(matches!(run(Some(&offer)), Current { .. }));
|
||||
fs::write(&latest, r#""2.2.0-beta.1""#).unwrap();
|
||||
assert!(matches!(run(Some(&offer)), Channel { .. }));
|
||||
fs::write(&latest, r#""2.1.12""#).unwrap();
|
||||
f.manifest("other-package", "2.1.9");
|
||||
assert_eq!(run(Some(&offer)), Unmanaged);
|
||||
assert!(!f.root.path().join("installed").exists());
|
||||
f.manifest(PKG, "2.1.12");
|
||||
fs::copy(f.install.folder.join("package.json"), f.root.path().join("updated.json")).unwrap();
|
||||
f.manifest(PKG, "2.1.9");
|
||||
assert_eq!(run(Some(&offer)), Updated { current: "2.1.12".into() });
|
||||
assert!(f.root.path().join("installed").exists());
|
||||
assert_eq!(run(None), Current { current: "2.1.12".into() });
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn permission_failure_never_starts_an_install() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let f = Fixture::new();
|
||||
let npm = f.npm(NPM);
|
||||
fs::write(f.root.path().join("latest"), r#""2.1.12""#).unwrap();
|
||||
let run = |offer: Option<&AgentCliOffer>| {
|
||||
maintain(&npm, &f.install.link, "claude", PKG, offer, &CancellationToken::new()).unwrap()
|
||||
};
|
||||
let AgentCliUpdateResult::Available(offer) = run(None) else { panic!("expected an offer") };
|
||||
fs::set_permissions(&f.install.folder, fs::Permissions::from_mode(0o555)).unwrap();
|
||||
// root can write even when no mode bit grants write permission.
|
||||
if tempfile::tempfile_in(&f.install.folder).is_err() {
|
||||
assert_eq!(run(Some(&offer)), AgentCliUpdateResult::Permission(offer));
|
||||
}
|
||||
fs::set_permissions(&f.install.folder, fs::Permissions::from_mode(0o755)).unwrap();
|
||||
assert!(!f.root.path().join("installed").exists());
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn cancellation_stops_a_running_npm_process() {
|
||||
use std::time::{Duration, Instant};
|
||||
let f = Fixture::new();
|
||||
let npm = f.npm(
|
||||
r#"case "$1" in
|
||||
prefix) pwd -P ;;
|
||||
view) echo '"2.1.12"' ;;
|
||||
install) touch started; exec sleep 30 ;;
|
||||
esac"#,
|
||||
);
|
||||
let cancel = CancellationToken::new();
|
||||
let AgentCliUpdateResult::Available(offer) =
|
||||
maintain(&npm, &f.install.link, "claude", PKG, None, &cancel).unwrap()
|
||||
else {
|
||||
panic!("expected an offer")
|
||||
};
|
||||
let started = f.root.path().join("started");
|
||||
std::thread::scope(|s| {
|
||||
let op = s.spawn(|| maintain(&npm, &f.install.link, "claude", PKG, Some(&offer), &cancel));
|
||||
let deadline = Instant::now() + Duration::from_secs(5);
|
||||
while !started.exists() && Instant::now() < deadline {
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
}
|
||||
cancel.cancel();
|
||||
assert!(started.exists());
|
||||
assert_eq!(op.join().unwrap().unwrap_err().kind, ErrorKind::Cancelled);
|
||||
});
|
||||
assert_eq!(f.version().as_deref(), Some("2.1.9"));
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@
|
||||
mod acp;
|
||||
mod async_questions;
|
||||
mod catalogs;
|
||||
mod cli_update;
|
||||
mod config;
|
||||
mod conversation;
|
||||
mod elicitation;
|
||||
@@ -27,6 +28,7 @@ mod timeline;
|
||||
mod worktree;
|
||||
|
||||
pub use catalogs::AgentCatalogs;
|
||||
pub use cli_update::{AgentCliOffer, AgentCliUpdateResult};
|
||||
pub use external::ExternalSession;
|
||||
pub use model::*;
|
||||
|
||||
|
||||
@@ -614,6 +614,9 @@ pub struct AgentProvider {
|
||||
pub command_read_only_reason: Option<AgentCommandReadOnlyReason>,
|
||||
/// Whether the command was found (on `PATH`).
|
||||
pub installed: bool,
|
||||
/// The built-in command can be owned by a global npm package.
|
||||
#[serde(default)]
|
||||
pub can_check_cli_update: bool,
|
||||
/// Environment variables it starts with (from its agent file).
|
||||
pub env: BTreeMap<String, String>,
|
||||
/// Settings (models, modes…) the agent offered last time it ran; empty before its first session.
|
||||
|
||||
@@ -373,6 +373,7 @@ pub(crate) fn describe(spec: &ProviderSpec) -> AgentProvider {
|
||||
command_editable: reason.is_none(),
|
||||
command_read_only_reason: reason,
|
||||
installed: installed(&spec.command),
|
||||
can_check_cli_update: spec.source == AgentSource::Builtin && crate::cli_update::package(&spec.id).is_some(),
|
||||
env: spec.env.iter().cloned().collect(),
|
||||
config: vec![],
|
||||
thought_levels: BTreeMap::new(),
|
||||
|
||||
@@ -197,6 +197,7 @@ pub enum ImportsOnPaste {
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct FoldingSettings {
|
||||
pub show_outline: bool,
|
||||
pub outline_visibility: FoldingOutlineVisibility,
|
||||
pub file_header: bool,
|
||||
pub imports: bool,
|
||||
pub doc_comments: bool,
|
||||
@@ -204,10 +205,24 @@ pub struct FoldingSettings {
|
||||
|
||||
impl Default for FoldingSettings {
|
||||
fn default() -> Self {
|
||||
Self { show_outline: true, file_header: true, imports: true, doc_comments: false }
|
||||
Self {
|
||||
show_outline: true,
|
||||
outline_visibility: FoldingOutlineVisibility::Hover,
|
||||
file_header: true,
|
||||
imports: true,
|
||||
doc_comments: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum FoldingOutlineVisibility {
|
||||
#[default]
|
||||
Hover,
|
||||
Always,
|
||||
}
|
||||
|
||||
/// Editor › General › Editor Tabs.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
@@ -543,3 +558,24 @@ mod auto_import_tests {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod folding_tests {
|
||||
use super::{FoldingOutlineVisibility, FoldingSettings};
|
||||
|
||||
#[test]
|
||||
fn folding_outline_defaults_to_hover_for_existing_settings() {
|
||||
let settings: FoldingSettings = serde_json::from_str(r#"{"showOutline":false}"#).unwrap();
|
||||
assert!(!settings.show_outline);
|
||||
assert_eq!(settings.outline_visibility, FoldingOutlineVisibility::Hover);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn folding_outline_visibility_round_trips() {
|
||||
for mode in ["hover", "always"] {
|
||||
let json = serde_json::json!({ "outlineVisibility": mode });
|
||||
let settings: FoldingSettings = serde_json::from_value(json).unwrap();
|
||||
assert_eq!(serde_json::to_value(settings).unwrap()["outlineVisibility"], mode);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -15,6 +15,7 @@ pub mod inspection_settings;
|
||||
pub mod ipc_path;
|
||||
pub mod java_runtime;
|
||||
pub mod jsonc;
|
||||
pub mod memory;
|
||||
pub mod output_encoding;
|
||||
pub mod platform;
|
||||
pub mod process;
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
//! Returning freed heap pages to the OS.
|
||||
|
||||
/// Hands pages the allocator has freed but kept back to the OS. Call after a burst of
|
||||
/// short-lived allocations (a full index scan); until then they still count towards the
|
||||
/// process's memory footprint.
|
||||
pub fn release_free_pages() {
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
unsafe extern "C" {
|
||||
fn malloc_zone_pressure_relief(zone: *mut std::ffi::c_void, goal: usize) -> usize;
|
||||
}
|
||||
// SAFETY: a null zone covers every zone; a zero goal releases as much as possible.
|
||||
unsafe { malloc_zone_pressure_relief(std::ptr::null_mut(), 0) };
|
||||
}
|
||||
#[cfg(all(target_os = "linux", target_env = "gnu"))]
|
||||
// SAFETY: malloc_trim only returns free memory to the OS.
|
||||
unsafe {
|
||||
libc::malloc_trim(0);
|
||||
}
|
||||
}
|
||||
@@ -11,6 +11,8 @@ use std::collections::BTreeMap;
|
||||
pub struct VcsSettings {
|
||||
/// Colour folders that contain changed files (project tree, tabs).
|
||||
pub show_dirty_directories: bool,
|
||||
/// Diffs the user opens show in an editor tab; off, in a separate window.
|
||||
pub diff_as_editor_tab: bool,
|
||||
/// Stop file history (Show History) after `history_limit` commits.
|
||||
pub limit_history: bool,
|
||||
pub history_limit: u32,
|
||||
@@ -55,6 +57,7 @@ impl Default for VcsSettings {
|
||||
Self {
|
||||
// IDEA's VcsConfiguration.SHOW_DIRTY_RECURSIVELY is off by default.
|
||||
show_dirty_directories: false,
|
||||
diff_as_editor_tab: true,
|
||||
limit_history: true,
|
||||
history_limit: 1000,
|
||||
git: GitSettings::default(),
|
||||
|
||||
@@ -49,6 +49,8 @@ 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`.
|
||||
@@ -60,6 +62,7 @@ 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 {
|
||||
@@ -130,12 +133,15 @@ 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" => cfg(
|
||||
"com.microsoft.java.debug.plugin.jar",
|
||||
&[],
|
||||
"tcp",
|
||||
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
|
||||
),
|
||||
"java-debug" => DebuggerConfig {
|
||||
resolve_lazy_variables: true,
|
||||
..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(
|
||||
@@ -186,6 +192,7 @@ 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,6 +102,7 @@ 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,6 +236,11 @@ 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`).
|
||||
@@ -727,9 +732,46 @@ 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))
|
||||
@@ -1497,6 +1539,7 @@ 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,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -1567,16 +1610,18 @@ impl DebugManager {
|
||||
}
|
||||
|
||||
pub async fn variables(&self, s: DebugSessionId, reference: i64) -> IdeResult<Vec<Variable>> {
|
||||
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())
|
||||
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
|
||||
}
|
||||
|
||||
/// Evaluates in the `repl` context.
|
||||
@@ -1602,13 +1647,18 @@ impl DebugManager {
|
||||
args["frameId"] = f.into();
|
||||
}
|
||||
let body = session.conn.request_timeout("evaluate", args, REQUEST_TIMEOUT).await?;
|
||||
Ok(Variable {
|
||||
let result = 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
|
||||
@@ -1713,7 +1763,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: true });
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: false });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1825,7 +1875,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: true });
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: false });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
@@ -505,13 +505,29 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
"scopes" => {
|
||||
ok!(msg, json!({"scopes": [{"name": "Locals", "variablesReference": 100, "expensive": false}]}))
|
||||
}
|
||||
"variables" => ok!(
|
||||
msg,
|
||||
json!({"variables": [
|
||||
{"name": "x", "value": "1", "type": "int", "variablesReference": 0},
|
||||
{"name": "req", "value": "{Req}", "type": "Req", "variablesReference": 101, "evaluateName": "req"},
|
||||
]})
|
||||
),
|
||||
// 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"},
|
||||
]})
|
||||
),
|
||||
},
|
||||
"evaluate" => ok!(msg, json!({"result": "42", "type": "int", "variablesReference": 0})),
|
||||
"completions" => ok!(
|
||||
msg,
|
||||
@@ -2020,6 +2036,7 @@ 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,
|
||||
}),
|
||||
};
|
||||
@@ -2763,6 +2780,53 @@ 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,30 +145,38 @@ impl ClickhousePool {
|
||||
let cancel = CancellationToken::new();
|
||||
let initialize = async {
|
||||
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
|
||||
if !rejects_driver_setting(&error) {
|
||||
let Some(setting) = rejected_driver_setting(&error) else {
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
if !use_http_session {
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Retry only the connection probe. Keep relying on the server for write protection
|
||||
// only after verifying strict read-only mode in this same session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// Start the proof in a fresh session: the rejected probe may have left
|
||||
// its id on another replica without applying the configured database.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
if setting == "readonly" {
|
||||
return Err(error);
|
||||
}
|
||||
if !source.read_only {
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; enable Read-only for independent queries on a strict read-only server",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Every request still sends readonly=1, regardless of which node answers.
|
||||
pool.0.session.lock().await.strict_read_only = true;
|
||||
pool.execute("SELECT 1", 1, &cancel).await?;
|
||||
} else {
|
||||
// Only rely on the server's write protection after proving strict read-only
|
||||
// in this same named session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// The rejected probe may have opened a session on a different node.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
// The HTTP database parameter applies to one request. A named session needs
|
||||
@@ -236,7 +244,7 @@ impl ClickhousePool {
|
||||
if !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
|
||||
request = request.query(&[("database", &self.0.database)]);
|
||||
}
|
||||
if self.0.read_only && !session.strict_read_only {
|
||||
if self.0.read_only && (session.id.is_none() || !session.strict_read_only) {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
request
|
||||
@@ -324,7 +332,7 @@ impl ClickhousePool {
|
||||
result
|
||||
}
|
||||
None => {
|
||||
let killed = self.kill(&client, &query_id).await;
|
||||
let killed = self.kill(&client, &query_id, &session).await;
|
||||
match killed {
|
||||
Ok(()) => Err(IdeError::cancelled()),
|
||||
Err(error) => Err(IdeError::new(
|
||||
@@ -336,15 +344,16 @@ impl ClickhousePool {
|
||||
}
|
||||
}
|
||||
|
||||
async fn kill(&self, client: &Client, query_id: &str) -> IdeResult<()> {
|
||||
let response = client
|
||||
async fn kill(&self, client: &Client, query_id: &str, session: &Session) -> IdeResult<()> {
|
||||
let mut request = client
|
||||
.post(self.0.endpoint.clone())
|
||||
.basic_auth(&self.0.user, Some(&self.0.password))
|
||||
.timeout(Duration::from_secs(3))
|
||||
.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC"))
|
||||
.send()
|
||||
.await
|
||||
.map_err(http_error)?;
|
||||
.timeout(Duration::from_secs(3));
|
||||
if self.0.read_only && session.id.is_none() {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
let response =
|
||||
request.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")).send().await.map_err(http_error)?;
|
||||
let status = response.status();
|
||||
let code = response
|
||||
.headers()
|
||||
@@ -551,13 +560,14 @@ fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
|
||||
.map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
|
||||
}
|
||||
|
||||
fn rejects_driver_setting(error: &IdeError) -> bool {
|
||||
fn rejected_driver_setting(error: &IdeError) -> Option<&str> {
|
||||
error
|
||||
.message
|
||||
.split_once(": ")
|
||||
.and_then(|(_, detail)| detail.strip_prefix("Code: 164. DB::Exception: Cannot modify '"))
|
||||
.and_then(|detail| detail.split_once("' setting in readonly mode"))
|
||||
.is_some_and(|(name, _)| {
|
||||
.map(|(name, _)| name)
|
||||
.filter(|&name| {
|
||||
matches!(
|
||||
name,
|
||||
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
|
||||
@@ -953,19 +963,77 @@ mod tests {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
|
||||
for read_only in [false, true] {
|
||||
let (port, requests) = server(vec![(
|
||||
async fn strict_stateless_connections_keep_readonly_on_every_request() {
|
||||
let denied = "Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)";
|
||||
let (port, requests) = server(vec![
|
||||
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", denied),
|
||||
("200 OK", "", ONE),
|
||||
(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot execute query in readonly mode. (READONLY)",
|
||||
),
|
||||
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[0]\n[1]\n[2]\n"),
|
||||
])
|
||||
.await;
|
||||
let source = DataSource {
|
||||
database: "fixture_database".into(),
|
||||
read_only: true,
|
||||
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let write = "CREATE TABLE fixture_table (n UInt8) ENGINE=Memory";
|
||||
assert!(pool.execute(write, 1, &cancel).await.unwrap_err().message.contains("Code: 164"));
|
||||
let sql = "SELECT number AS n FROM numbers(3) LIMIT 3";
|
||||
let result = pool.execute(sql, 1, &cancel).await.unwrap();
|
||||
assert_eq!(result.rows, vec![vec![Some("0".into())]]);
|
||||
assert!(result.has_more);
|
||||
let requests = requests.await.unwrap();
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[1].ends_with("SELECT 1"));
|
||||
assert!(requests[2].ends_with(write));
|
||||
assert!(requests[3].ends_with(sql));
|
||||
for (index, request) in requests.iter().enumerate() {
|
||||
let url = request_url(request);
|
||||
for name in ["session_id", "session_check", "session_timeout", "use_http_session"] {
|
||||
assert_eq!(query_value(&url, name), None, "{name}");
|
||||
}
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "database").as_deref(), Some("fixture_database"));
|
||||
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
|
||||
assert_eq!(query_value(&url, "max_result_rows").as_deref(), (index == 0).then_some("2"));
|
||||
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), (index == 0).then_some("break"));
|
||||
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), (index == 0).then_some("1"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_connections_require_readonly_and_only_relax_driver_result_settings() {
|
||||
for (read_only, detail, body) in [
|
||||
(
|
||||
false,
|
||||
"enable Read-only",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
|
||||
)])
|
||||
.await;
|
||||
),
|
||||
(
|
||||
true,
|
||||
"Cannot modify 'readonly'",
|
||||
"Code: 164. DB::Exception: Cannot modify 'readonly' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
(
|
||||
true,
|
||||
"Cannot modify 'max_threads'",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_threads' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
] {
|
||||
let (port, requests) =
|
||||
server(vec![("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", body)]).await;
|
||||
let source =
|
||||
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
|
||||
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
|
||||
assert!(error.message.contains("use_http_session=false requires per-request"));
|
||||
assert!(error.message.contains(detail), "{}", error.message);
|
||||
let requests = requests.await.unwrap();
|
||||
assert_eq!(requests.len(), 1);
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
@@ -1041,7 +1109,7 @@ mod tests {
|
||||
let error = IdeError::invalid(format!(
|
||||
"ClickHouse HTTP 500: Code: {code}. DB::Exception: Cannot modify '{setting}' setting in readonly mode. (READONLY)"
|
||||
));
|
||||
assert_eq!(rejects_driver_setting(&error), expected, "{setting}");
|
||||
assert_eq!(rejected_driver_setting(&error).is_some(), expected, "{setting}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1084,37 +1152,45 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn cancellation_sends_kill_outside_the_busy_session() {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let (started, received) = tokio::sync::oneshot::channel();
|
||||
let server = tokio::spawn(async move {
|
||||
let (mut health, _) = listener.accept().await.unwrap();
|
||||
read_request(&mut health).await;
|
||||
reply(&mut health, "200 OK", "", ONE).await;
|
||||
drop(health);
|
||||
let (mut query, _) = listener.accept().await.unwrap();
|
||||
let request = read_request(&mut query).await;
|
||||
started.send(()).unwrap();
|
||||
let (mut kill, _) = tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
|
||||
let kill_request = read_request(&mut kill).await;
|
||||
reply(&mut kill, "200 OK", "", "").await;
|
||||
(request, kill_request)
|
||||
});
|
||||
let pool = Pool::connect(&source(port), None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
|
||||
let cancelled = async {
|
||||
received.await.unwrap();
|
||||
cancel.cancel();
|
||||
};
|
||||
let (result, ()) = tokio::join!(query, cancelled);
|
||||
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
|
||||
let (query, kill) = server.await.unwrap();
|
||||
let target = query.lines().next().unwrap().split_whitespace().nth(1).unwrap();
|
||||
let url = Url::parse(&format!("http://localhost{target}")).unwrap();
|
||||
let query_id = url.query_pairs().find(|(k, _)| k == "query_id").unwrap().1.into_owned();
|
||||
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
|
||||
assert!(!kill.contains("session_id="));
|
||||
for stateless in [false, true] {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let (started, received) = tokio::sync::oneshot::channel();
|
||||
let server = tokio::spawn(async move {
|
||||
let (mut health, _) = listener.accept().await.unwrap();
|
||||
read_request(&mut health).await;
|
||||
reply(&mut health, "200 OK", "", ONE).await;
|
||||
drop(health);
|
||||
let (mut query, _) = listener.accept().await.unwrap();
|
||||
let request = read_request(&mut query).await;
|
||||
started.send(()).unwrap();
|
||||
let (mut kill, _) =
|
||||
tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
|
||||
let kill_request = read_request(&mut kill).await;
|
||||
reply(&mut kill, "200 OK", "", "").await;
|
||||
(request, kill_request)
|
||||
});
|
||||
let source = DataSource {
|
||||
read_only: true,
|
||||
properties: vec![property("use_http_session", if stateless { "false" } else { "true" })],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
|
||||
let cancelled = async {
|
||||
received.await.unwrap();
|
||||
cancel.cancel();
|
||||
};
|
||||
let (result, ()) = tokio::join!(query, cancelled);
|
||||
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
|
||||
let (query, kill) = server.await.unwrap();
|
||||
let query_id = query_value(&request_url(&query), "query_id").unwrap();
|
||||
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
|
||||
let url = request_url(&kill);
|
||||
assert_eq!(query_value(&url, "session_id"), None);
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), stateless.then_some("1"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
@@ -303,7 +303,9 @@ async fn read_frame(output: &mut (impl AsyncRead + Unpin)) -> IdeResult<Vec<u8>>
|
||||
const CANCEL_GRACE: Duration = Duration::from_secs(3);
|
||||
|
||||
fn cancel_timeout() -> IdeError {
|
||||
IdeError::invalid("The JDBC driver did not stop in time. The session was closed. Reconnect to continue.")
|
||||
IdeError::invalid(
|
||||
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect.",
|
||||
)
|
||||
}
|
||||
|
||||
async fn exchange(
|
||||
|
||||
@@ -210,9 +210,13 @@ async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
|
||||
})
|
||||
.await
|
||||
.expect("driver cancellation must be bounded");
|
||||
assert!(result.unwrap_err().message.contains("Reconnect"));
|
||||
db.disconnect("test").await;
|
||||
assert_eq!(db.execute("test", "after reconnect", 1, &normal).await?.affected, Some(1.0));
|
||||
assert_eq!(
|
||||
result.unwrap_err().message,
|
||||
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect."
|
||||
);
|
||||
assert!(db.connected().is_empty());
|
||||
assert_eq!(db.execute("test", "after cancellation", 1, &normal).await?.affected, Some(1.0));
|
||||
assert_eq!(db.connected(), ["test"]);
|
||||
db.disconnect("test").await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
[package]
|
||||
name = "ide-drag-out"
|
||||
description = "OS file drags out of an app window, so file managers and transfer clients copy the files: GTK on Linux, OLE on Windows, AppKit on macOS"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[dependencies]
|
||||
|
||||
[target.'cfg(target_os = "linux")'.dependencies]
|
||||
gtk = "0.18"
|
||||
|
||||
[target.'cfg(any(windows, target_os = "macos"))'.dependencies]
|
||||
raw-window-handle = "0.6"
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows = { version = "0.62", features = [
|
||||
"Win32_Foundation",
|
||||
"Win32_Graphics_Gdi",
|
||||
"Win32_System_Com",
|
||||
"Win32_System_Com_StructuredStorage",
|
||||
"Win32_System_Memory",
|
||||
"Win32_System_Ole",
|
||||
"Win32_System_SystemServices",
|
||||
"Win32_UI_Shell",
|
||||
"Win32_UI_Shell_Common",
|
||||
] }
|
||||
# `#[implement]` expands to paths into `windows_core`.
|
||||
windows-core = "0.62"
|
||||
|
||||
[target.'cfg(target_os = "macos")'.dependencies]
|
||||
objc2 = { version = "0.6", default-features = false, features = ["std"] }
|
||||
objc2-foundation = { version = "0.3", default-features = false, features = ["std", "NSArray", "NSGeometry", "NSObject", "NSString", "NSURL"] }
|
||||
objc2-app-kit = { version = "0.3", default-features = false, features = [
|
||||
"std",
|
||||
"objc2-core-foundation",
|
||||
"NSApplication",
|
||||
"NSDragging",
|
||||
"NSDraggingItem",
|
||||
"NSDraggingSession",
|
||||
"NSEvent",
|
||||
"NSGraphics",
|
||||
"NSGraphicsContext",
|
||||
"NSImage",
|
||||
"NSPasteboard",
|
||||
"NSPasteboardItem",
|
||||
"NSResponder",
|
||||
"NSView",
|
||||
"NSWindow",
|
||||
"NSWorkspace",
|
||||
] }
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile.workspace = true
|
||||
@@ -0,0 +1,122 @@
|
||||
//! macOS: an AppKit dragging session with one pasteboard item per path, each a file URL.
|
||||
|
||||
use super::Outcome;
|
||||
use objc2::rc::Retained;
|
||||
use objc2::runtime::ProtocolObject;
|
||||
use objc2::{AnyThread, DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send};
|
||||
use objc2_app_kit::{
|
||||
NSApplication, NSDragOperation, NSDraggingContext, NSDraggingItem, NSDraggingSession, NSDraggingSource, NSEvent,
|
||||
NSEventModifierFlags, NSEventType, NSPasteboardItem, NSPasteboardTypeFileURL, NSView, NSWorkspace,
|
||||
};
|
||||
use objc2_foundation::{NSArray, NSObject, NSObjectProtocol, NSPoint, NSRect, NSSize, NSString, NSURL};
|
||||
use raw_window_handle::{HasWindowHandle, RawWindowHandle};
|
||||
use std::cell::Cell;
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// The size of each file's icon under the pointer, in points.
|
||||
const ICON_SIZE: f64 = 32.0;
|
||||
|
||||
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`, each shown with its
|
||||
/// Finder icon; `done` runs on the main thread when the drag ends.
|
||||
pub fn start<W: HasWindowHandle>(
|
||||
window: &W,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
let mtm = MainThreadMarker::new().ok_or_else(|| io::Error::other("a drag starts on the main thread"))?;
|
||||
let RawWindowHandle::AppKit(handle) =
|
||||
window.window_handle().map_err(|error| io::Error::other(error.to_string()))?.as_raw()
|
||||
else {
|
||||
return Err(io::Error::other("not an AppKit window"));
|
||||
};
|
||||
// SAFETY: the handle names this window's view, alive while `window` is borrowed.
|
||||
let view = unsafe { handle.ns_view.cast::<NSView>().as_ref() };
|
||||
let window = view.window().ok_or_else(|| io::Error::other("the view has no window"))?;
|
||||
let content = window.contentView().ok_or_else(|| io::Error::other("the window has no content view"))?;
|
||||
// In window coordinates, which are the content view's.
|
||||
let pointer = window.mouseLocationOutsideOfEventStream();
|
||||
let frame = NSRect::new(
|
||||
NSPoint::new(pointer.x - ICON_SIZE / 2.0, pointer.y - ICON_SIZE / 2.0),
|
||||
NSSize::new(ICON_SIZE, ICON_SIZE),
|
||||
);
|
||||
|
||||
let workspace = NSWorkspace::sharedWorkspace();
|
||||
let mut items = Vec::with_capacity(paths.len());
|
||||
for path in &paths {
|
||||
let path = NSString::from_str(&path.to_string_lossy());
|
||||
let url = NSURL::fileURLWithPath(&path)
|
||||
.absoluteString()
|
||||
.ok_or_else(|| io::Error::other(format!("not a file URL: {path}")))?;
|
||||
let item = NSPasteboardItem::new();
|
||||
if !item.setString_forType(&url, unsafe { NSPasteboardTypeFileURL }) {
|
||||
return Err(io::Error::other(format!("cannot put {path} on the pasteboard")));
|
||||
}
|
||||
let drag_item =
|
||||
NSDraggingItem::initWithPasteboardWriter(NSDraggingItem::alloc(), ProtocolObject::from_ref(&*item));
|
||||
let icon = workspace.iconForFile(&path);
|
||||
unsafe { drag_item.setDraggingFrame_contents(frame, Some(&icon)) };
|
||||
items.push(drag_item);
|
||||
}
|
||||
|
||||
// The session starts from a drag event at the pointer: the web view's own mouse events
|
||||
// went to WebKit, and the current event may be a later one.
|
||||
let timestamp = NSApplication::sharedApplication(mtm).currentEvent().map_or(0.0, |event| event.timestamp());
|
||||
let event = NSEvent::mouseEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_clickCount_pressure(
|
||||
NSEventType::LeftMouseDragged,
|
||||
pointer,
|
||||
NSEventModifierFlags::empty(),
|
||||
timestamp,
|
||||
window.windowNumber(),
|
||||
None,
|
||||
0,
|
||||
1,
|
||||
1.0,
|
||||
)
|
||||
.ok_or_else(|| io::Error::other("cannot make the drag event"))?;
|
||||
let source = DragSource::new(Box::new(done), mtm);
|
||||
content.beginDraggingSessionWithItems_event_source(
|
||||
&NSArray::from_retained_slice(&items),
|
||||
&event,
|
||||
ProtocolObject::from_ref(&*source),
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
type Done = Box<dyn FnOnce(Outcome)>;
|
||||
|
||||
struct Ivars {
|
||||
done: Cell<Option<Done>>,
|
||||
}
|
||||
|
||||
define_class!(
|
||||
#[unsafe(super(NSObject))]
|
||||
#[thread_kind = MainThreadOnly]
|
||||
#[name = "OpenIdeaDragOutSource"]
|
||||
#[ivars = Ivars]
|
||||
struct DragSource;
|
||||
|
||||
unsafe impl NSObjectProtocol for DragSource {}
|
||||
|
||||
unsafe impl NSDraggingSource for DragSource {
|
||||
#[unsafe(method(draggingSession:sourceOperationMaskForDraggingContext:))]
|
||||
fn operation_mask(&self, session: &NSDraggingSession, _context: NSDraggingContext) -> NSDragOperation {
|
||||
session.setAnimatesToStartingPositionsOnCancelOrFail(true);
|
||||
NSDragOperation::Copy
|
||||
}
|
||||
|
||||
#[unsafe(method(draggingSession:endedAtPoint:operation:))]
|
||||
fn ended(&self, _session: &NSDraggingSession, _point: NSPoint, operation: NSDragOperation) {
|
||||
if let Some(done) = self.ivars().done.take() {
|
||||
done(if operation == NSDragOperation::None { Outcome::Cancelled } else { Outcome::Dropped });
|
||||
}
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
impl DragSource {
|
||||
fn new(done: Done, mtm: MainThreadMarker) -> Retained<Self> {
|
||||
let this = Self::alloc(mtm).set_ivars(Ivars { done: Cell::new(Some(done)) });
|
||||
unsafe { msg_send![super(this), init] }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,190 @@
|
||||
//! OS file drags out of an app window: the app the files are dropped on (Explorer,
|
||||
//! Finder, a file manager, an SFTP client such as Xftp) copies them, as when they are
|
||||
//! dragged from IDEA's Project view (#2867).
|
||||
//!
|
||||
//! Linux starts a GTK drag offering `text/uri-list`, Windows an OLE `DoDragDrop` of a
|
||||
//! `CF_HDROP` data object, macOS an AppKit dragging session of file URLs. A drag is
|
||||
//! always a copy, never a move, so no target can take project files away.
|
||||
//!
|
||||
//! [`start`] runs on the UI thread while the primary button is still held. It returns
|
||||
//! once the drag has begun (Linux, macOS) or ended (Windows); `done` gets the outcome
|
||||
//! when it ends, or is dropped without being called when the backend lost track of it.
|
||||
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// How a drag ended.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Outcome {
|
||||
/// A target accepted the drop.
|
||||
Dropped,
|
||||
/// Released where nothing accepted it, or cancelled with Escape.
|
||||
Cancelled,
|
||||
}
|
||||
|
||||
/// The paths a drag may carry: at least one, each an absolute path to a file or folder
|
||||
/// on this machine. A remote project's paths name files on its server and fail here.
|
||||
/// Windows also refuses paths of `MAX_PATH` or more: Explorer can't copy from them.
|
||||
/// Network shares (`\\server\share\…`) are local paths here and drag like any other.
|
||||
pub fn local_paths<S: Into<PathBuf>>(paths: impl IntoIterator<Item = S>) -> io::Result<Vec<PathBuf>> {
|
||||
let paths: Vec<PathBuf> = paths.into_iter().map(Into::into).collect();
|
||||
if paths.is_empty() {
|
||||
return Err(io::Error::new(io::ErrorKind::InvalidInput, "no files to drag"));
|
||||
}
|
||||
for path in &paths {
|
||||
if !path.is_absolute() || std::fs::symlink_metadata(path).is_err() {
|
||||
return Err(io::Error::new(io::ErrorKind::NotFound, format!("not a local file: {}", path.display())));
|
||||
}
|
||||
if cfg!(windows) && !fits_max_path(path) {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
format!("path too long to drag: {}", path.display()),
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(paths)
|
||||
}
|
||||
|
||||
/// Whether `path` is shorter than Windows' `MAX_PATH` (260 UTF-16 units with the NUL).
|
||||
fn fits_max_path(path: &std::path::Path) -> bool {
|
||||
path.as_os_str().to_string_lossy().encode_utf16().count() < 260
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
pub use gtk_impl::start;
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
mod gtk_impl {
|
||||
use super::Outcome;
|
||||
use gtk::glib::{self, SignalHandlerId};
|
||||
use gtk::prelude::*;
|
||||
use gtk::{TargetList, gdk};
|
||||
use std::cell::{Cell, RefCell};
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
use std::rc::Rc;
|
||||
|
||||
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`; `done` runs on
|
||||
/// the UI thread when the drag ends.
|
||||
pub fn start(
|
||||
window: >k::ApplicationWindow,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
// `file://` URIs with every reserved or non-ASCII byte escaped.
|
||||
let uris = paths
|
||||
.iter()
|
||||
.map(|path| glib::filename_to_uri(path, None).map(|uri| uri.to_string()))
|
||||
.collect::<Result<Vec<_>, _>>()
|
||||
.map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error.to_string()))?;
|
||||
let targets = TargetList::new(&[]);
|
||||
targets.add_uri_targets(0);
|
||||
// The button that started the drag (1), not its mask: GTK ends the drag on that
|
||||
// button's release.
|
||||
let context = window
|
||||
.drag_begin_with_coordinates(&targets, gdk::DragAction::COPY, 1, None, -1, -1)
|
||||
.ok_or_else(|| io::Error::other("the window system refused to start a drag"))?;
|
||||
|
||||
let outcome = Rc::new(Cell::new(Outcome::Cancelled));
|
||||
context.connect_drop_performed({
|
||||
let outcome = outcome.clone();
|
||||
move |_, _| outcome.set(Outcome::Dropped)
|
||||
});
|
||||
let handlers: Rc<RefCell<Vec<SignalHandlerId>>> = Rc::default();
|
||||
let data = window.connect_drag_data_get({
|
||||
let context = context.clone();
|
||||
move |_, ctx, selection, _, _| {
|
||||
if *ctx == context {
|
||||
let uris: Vec<&str> = uris.iter().map(String::as_str).collect();
|
||||
selection.set_uris(&uris);
|
||||
}
|
||||
}
|
||||
});
|
||||
// The target asks for the data after the drop (XDND is asynchronous), so the data
|
||||
// handler stays connected until `drag-end`, which GTK emits last.
|
||||
let done = Cell::new(Some(done));
|
||||
let end = window.connect_drag_end({
|
||||
let handlers = handlers.clone();
|
||||
move |window, ctx| {
|
||||
if *ctx != context {
|
||||
return;
|
||||
}
|
||||
for handler in handlers.borrow_mut().drain(..) {
|
||||
window.disconnect(handler);
|
||||
}
|
||||
if let Some(done) = done.take() {
|
||||
done(outcome.get());
|
||||
}
|
||||
}
|
||||
});
|
||||
handlers.borrow_mut().extend([data, end]);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
mod ole;
|
||||
#[cfg(windows)]
|
||||
pub use ole::start;
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
mod appkit;
|
||||
#[cfg(target_os = "macos")]
|
||||
pub use appkit::start;
|
||||
|
||||
/// The `CF_HDROP` file list: each path in UTF-16 with `/` as `\\`, NUL-terminated, and a
|
||||
/// second NUL after the last.
|
||||
#[cfg(any(windows, test))]
|
||||
fn hdrop_file_list<P: IntoIterator<Item = u16>>(paths: impl IntoIterator<Item = P>) -> Vec<u16> {
|
||||
let mut list = Vec::new();
|
||||
for path in paths {
|
||||
list.extend(path.into_iter().map(|unit| if unit == u16::from(b'/') { u16::from(b'\\') } else { unit }));
|
||||
list.push(0);
|
||||
}
|
||||
list.push(0);
|
||||
list
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn accepts_existing_absolute_files_and_folders() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let file = dir.path().join("a b ü.txt");
|
||||
std::fs::write(&file, "x").unwrap();
|
||||
let paths = local_paths([file.clone(), dir.path().to_path_buf()]).unwrap();
|
||||
assert_eq!(paths, vec![file, dir.path().to_path_buf()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn measures_max_path_in_utf16_units() {
|
||||
let path = |len: usize| PathBuf::from(format!("C:/{}", "中".repeat(len - 3)));
|
||||
assert!(fits_max_path(&path(259)));
|
||||
assert!(!fits_max_path(&path(260)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lists_hdrop_files_double_nul_terminated() {
|
||||
let list = hdrop_file_list(["C:/a b/ü.txt", r"\\nas\share\中"].map(str::encode_utf16));
|
||||
let expected: Vec<u16> = "C:\\a b\\ü.txt\0\\\\nas\\share\\中\0\0".encode_utf16().collect();
|
||||
assert_eq!(list, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_an_empty_drag() {
|
||||
assert_eq!(local_paths(Vec::<PathBuf>::new()).unwrap_err().kind(), io::ErrorKind::InvalidInput);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_relative_and_missing_paths() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let file = dir.path().join("a.txt");
|
||||
std::fs::write(&file, "x").unwrap();
|
||||
// One path that is not local fails the whole drag: none of it is half-copied.
|
||||
for bad in [PathBuf::from("a.txt"), dir.path().join("missing.txt")] {
|
||||
assert_eq!(local_paths([file.clone(), bad]).unwrap_err().kind(), io::ErrorKind::NotFound);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,171 @@
|
||||
//! Windows: OLE `DoDragDrop` of a data object that serves the paths as `CF_HDROP`.
|
||||
|
||||
use super::{Outcome, hdrop_file_list};
|
||||
use raw_window_handle::HasWindowHandle;
|
||||
use std::io;
|
||||
use std::os::windows::ffi::OsStrExt;
|
||||
use std::path::PathBuf;
|
||||
use windows::Win32::Foundation::{
|
||||
DRAGDROP_S_CANCEL, DRAGDROP_S_DROP, DRAGDROP_S_USEDEFAULTCURSORS, DV_E_FORMATETC, E_NOTIMPL, GlobalFree, HGLOBAL,
|
||||
OLE_E_ADVISENOTSUPPORTED, S_OK,
|
||||
};
|
||||
use windows::Win32::System::Com::{
|
||||
DATADIR_GET, DVASPECT_CONTENT, FORMATETC, IAdviseSink, IDataObject, IDataObject_Impl, IEnumFORMATETC,
|
||||
IEnumSTATDATA, STGMEDIUM, STGMEDIUM_0, TYMED_HGLOBAL,
|
||||
};
|
||||
use windows::Win32::System::Memory::{GHND, GlobalAlloc, GlobalLock, GlobalUnlock};
|
||||
use windows::Win32::System::Ole::{
|
||||
CF_HDROP, DROPEFFECT, DROPEFFECT_COPY, DROPEFFECT_NONE, DoDragDrop, IDropSource, IDropSource_Impl, OleInitialize,
|
||||
OleUninitialize,
|
||||
};
|
||||
use windows::Win32::System::SystemServices::{MK_LBUTTON, MODIFIERKEYS_FLAGS};
|
||||
use windows::Win32::UI::Shell::{DROPFILES, SHCreateDataObject, SHCreateStdEnumFmtEtc};
|
||||
use windows::core::{BOOL, Error, HRESULT, Ref, Result, implement};
|
||||
|
||||
/// Drags `paths` (see [`super::local_paths`]) until the button is released, then calls
|
||||
/// `done` and returns. `DoDragDrop` runs its own message loop, so the window keeps painting.
|
||||
pub fn start<W: HasWindowHandle>(
|
||||
_window: &W,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
let files = hdrop_file_list(paths.iter().map(|path| path.as_os_str().encode_wide()));
|
||||
// The window's event loop has initialised OLE on this thread already; this takes a
|
||||
// reference that `OleUninitialize` gives back.
|
||||
unsafe { OleInitialize(None) }.map_err(io::Error::other)?;
|
||||
let outcome = drag(files);
|
||||
unsafe { OleUninitialize() };
|
||||
done(outcome.map_err(io::Error::other)?);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn drag(files: Vec<u16>) -> Result<Outcome> {
|
||||
// Formats other than `CF_HDROP` (the drag image, drop descriptions the shell sets on
|
||||
// the source's data object) are kept by a plain shell data object.
|
||||
let inner: IDataObject = unsafe { SHCreateDataObject(None, None, None::<&IDataObject>) }?;
|
||||
let data: IDataObject = DataObject { files, inner }.into();
|
||||
let source: IDropSource = DropSource.into();
|
||||
let mut effect = DROPEFFECT_NONE;
|
||||
match unsafe { DoDragDrop(&data, &source, DROPEFFECT_COPY, &mut effect) } {
|
||||
DRAGDROP_S_DROP if effect != DROPEFFECT_NONE => Ok(Outcome::Dropped),
|
||||
DRAGDROP_S_DROP | DRAGDROP_S_CANCEL => Ok(Outcome::Cancelled),
|
||||
error => Err(Error::from_hresult(error)),
|
||||
}
|
||||
}
|
||||
|
||||
#[implement(IDropSource)]
|
||||
struct DropSource;
|
||||
|
||||
impl IDropSource_Impl for DropSource_Impl {
|
||||
fn QueryContinueDrag(&self, escape_pressed: BOOL, keys: MODIFIERKEYS_FLAGS) -> HRESULT {
|
||||
if escape_pressed.as_bool() {
|
||||
DRAGDROP_S_CANCEL
|
||||
} else if keys & MK_LBUTTON == MODIFIERKEYS_FLAGS(0) {
|
||||
DRAGDROP_S_DROP
|
||||
} else {
|
||||
S_OK
|
||||
}
|
||||
}
|
||||
|
||||
fn GiveFeedback(&self, _effect: DROPEFFECT) -> HRESULT {
|
||||
DRAGDROP_S_USEDEFAULTCURSORS
|
||||
}
|
||||
}
|
||||
|
||||
#[implement(IDataObject)]
|
||||
struct DataObject {
|
||||
/// The `DROPFILES` file list ([`hdrop_file_list`]).
|
||||
files: Vec<u16>,
|
||||
inner: IDataObject,
|
||||
}
|
||||
|
||||
const HDROP: FORMATETC = FORMATETC {
|
||||
cfFormat: CF_HDROP.0,
|
||||
ptd: std::ptr::null_mut(),
|
||||
dwAspect: DVASPECT_CONTENT.0,
|
||||
lindex: -1,
|
||||
tymed: TYMED_HGLOBAL.0 as u32,
|
||||
};
|
||||
|
||||
fn is_hdrop(format: *const FORMATETC) -> bool {
|
||||
unsafe { format.as_ref() }.is_some_and(|format| {
|
||||
format.cfFormat == HDROP.cfFormat && format.dwAspect == HDROP.dwAspect && format.tymed & HDROP.tymed != 0
|
||||
})
|
||||
}
|
||||
|
||||
impl DataObject {
|
||||
/// A new `DROPFILES` block; the receiver frees it.
|
||||
fn hdrop(&self) -> Result<HGLOBAL> {
|
||||
let header = size_of::<DROPFILES>();
|
||||
let size = header + std::mem::size_of_val(self.files.as_slice());
|
||||
unsafe {
|
||||
let handle = GlobalAlloc(GHND, size)?;
|
||||
let block = GlobalLock(handle).cast::<u8>();
|
||||
if block.is_null() {
|
||||
let error = Error::from_thread();
|
||||
let _ = GlobalFree(Some(handle));
|
||||
return Err(error);
|
||||
}
|
||||
block.cast::<DROPFILES>().write_unaligned(DROPFILES {
|
||||
pFiles: header as u32,
|
||||
fWide: true.into(),
|
||||
..Default::default()
|
||||
});
|
||||
std::ptr::copy_nonoverlapping(self.files.as_ptr().cast::<u8>(), block.add(header), size - header);
|
||||
// Fails with no error once the lock count is back to zero, which it is.
|
||||
let _ = GlobalUnlock(handle);
|
||||
Ok(handle)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl IDataObject_Impl for DataObject_Impl {
|
||||
fn GetData(&self, format: *const FORMATETC) -> Result<STGMEDIUM> {
|
||||
if !is_hdrop(format) {
|
||||
return unsafe { self.inner.GetData(format) };
|
||||
}
|
||||
Ok(STGMEDIUM {
|
||||
tymed: TYMED_HGLOBAL.0 as u32,
|
||||
u: STGMEDIUM_0 { hGlobal: self.hdrop()? },
|
||||
pUnkForRelease: std::mem::ManuallyDrop::new(None),
|
||||
})
|
||||
}
|
||||
|
||||
fn GetDataHere(&self, format: *const FORMATETC, medium: *mut STGMEDIUM) -> Result<()> {
|
||||
if is_hdrop(format) {
|
||||
return Err(DV_E_FORMATETC.into());
|
||||
}
|
||||
unsafe { self.inner.GetDataHere(format, medium) }
|
||||
}
|
||||
|
||||
fn QueryGetData(&self, format: *const FORMATETC) -> HRESULT {
|
||||
if is_hdrop(format) { S_OK } else { unsafe { self.inner.QueryGetData(format) } }
|
||||
}
|
||||
|
||||
fn GetCanonicalFormatEtc(&self, format: *const FORMATETC, canonical: *mut FORMATETC) -> HRESULT {
|
||||
unsafe { self.inner.GetCanonicalFormatEtc(format, canonical) }
|
||||
}
|
||||
|
||||
fn SetData(&self, format: *const FORMATETC, medium: *const STGMEDIUM, release: BOOL) -> Result<()> {
|
||||
unsafe { self.inner.SetData(format, medium, release.as_bool()) }
|
||||
}
|
||||
|
||||
fn EnumFormatEtc(&self, direction: u32) -> Result<IEnumFORMATETC> {
|
||||
if direction != DATADIR_GET.0 as u32 {
|
||||
return Err(E_NOTIMPL.into());
|
||||
}
|
||||
unsafe { SHCreateStdEnumFmtEtc(&[HDROP]) }
|
||||
}
|
||||
|
||||
fn DAdvise(&self, _format: *const FORMATETC, _advf: u32, _sink: Ref<IAdviseSink>) -> Result<u32> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
|
||||
fn DUnadvise(&self, _connection: u32) -> Result<()> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
|
||||
fn EnumDAdvise(&self) -> Result<IEnumSTATDATA> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
}
|
||||
@@ -5,10 +5,10 @@ use crate::Host;
|
||||
use crate::agent_secrets::{AgentSecrets, Kept};
|
||||
use ide_agent::registry::{AgentRegistry, RegistryPaths};
|
||||
use ide_agent::{
|
||||
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, AgentContextUsage,
|
||||
AgentEntry, AgentEvent, AgentModelCatalog, AgentProbe, AgentPrompt, AgentProvider, AgentQueued, AgentTask,
|
||||
CustomAgentInput, ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer,
|
||||
McpServerInput, McpTransport, NewAgentTask,
|
||||
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCliOffer,
|
||||
AgentCliUpdateResult, AgentCommand, AgentContextUsage, AgentEntry, AgentEvent, AgentModelCatalog, AgentProbe,
|
||||
AgentPrompt, AgentProvider, AgentQueued, AgentTask, CustomAgentInput, ExternalSession, McpExternalSource,
|
||||
McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput, McpTransport, NewAgentTask,
|
||||
};
|
||||
use ide_command::command;
|
||||
use ide_core::error::ErrorKind;
|
||||
@@ -359,6 +359,50 @@ pub async fn agent_rollback(host: &Host, window: &str, task: String, turns: u32)
|
||||
host.project(window)?.agents.rollback(&task, turns).await
|
||||
}
|
||||
|
||||
/// Checks the selected installation without modifying it.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_cli_update_check(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
request: RequestId,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
cli_update(host, window, provider, None, request).await
|
||||
}
|
||||
|
||||
/// Installs the exact version offered if the selected installation still matches.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_cli_update(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
offer: AgentCliOffer,
|
||||
request: RequestId,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
cli_update(host, window, provider, Some(offer), request).await
|
||||
}
|
||||
|
||||
async fn cli_update(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
offer: Option<AgentCliOffer>,
|
||||
request: RequestId,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
let installing = offer.as_ref().map(|_| Installing::begin(&provider)).transpose()?;
|
||||
let cancel = host.begin_project_request(window, request);
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
let _installing = installing;
|
||||
project.agents.cli_update(&provider, offer.as_ref(), &cancel)
|
||||
})
|
||||
.await
|
||||
.map_err(join_err);
|
||||
host.end_request(request);
|
||||
result?
|
||||
}
|
||||
|
||||
/// What the agent reports about itself when it starts (no session: no MCP servers, hooks
|
||||
/// or sign-in run). Remembered until `refresh`.
|
||||
#[command(trust = trusted)]
|
||||
@@ -1102,6 +1146,8 @@ ide_command::domain!(
|
||||
agent_cancel,
|
||||
agent_context_usage,
|
||||
agent_changes,
|
||||
agent_cli_update,
|
||||
agent_cli_update_check,
|
||||
agent_commands,
|
||||
agent_create,
|
||||
agent_delete,
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
//! Cucumber sources: the project's `.feature` files and the JavaScript / TypeScript files
|
||||
//! (`@cucumber/cucumber`, `playwright-bdd`) and Java / Kotlin files (cucumber-jvm's
|
||||
//! `@Given("…")` annotations and Java 8 lambdas) that could define steps, with their text. The UI
|
||||
//! `@Given("…")` annotations and Java 8 lambdas) and Python files (behave and pytest-bdd's
|
||||
//! `@given('…')` decorators) that could define steps, with their text. The UI
|
||||
//! owns the Gherkin and step-expression parsing and the index it feeds (as for `routes`),
|
||||
//! so this side stays a cheap scan.
|
||||
|
||||
@@ -21,6 +22,8 @@ const MAX_FILE_BYTES: u64 = 2 << 20;
|
||||
|
||||
/// What a step definition call starts with (`Given('…'`, `defineStep(/…/`).
|
||||
const STEP_CALLS: [&str; 5] = ["Given(", "When(", "Then(", "Step(", "defineStep("];
|
||||
/** What a Python step decorator starts with (behave also takes the capitalized names). */
|
||||
const PYTHON_STEP_CALLS: [&str; 8] = ["@given(", "@when(", "@then(", "@step(", "@Given(", "@When(", "@Then(", "@Step("];
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -38,10 +41,14 @@ fn is_feature(path: &Path) -> bool {
|
||||
fn is_script(path: &Path) -> bool {
|
||||
matches!(
|
||||
path.extension().and_then(|e| e.to_str()),
|
||||
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt")
|
||||
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt" | "py")
|
||||
)
|
||||
}
|
||||
|
||||
fn is_python(path: &Path) -> bool {
|
||||
path.extension().and_then(|e| e.to_str()) == Some("py")
|
||||
}
|
||||
|
||||
/// The feature files and step definition files under `root`.
|
||||
pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
|
||||
let found: Mutex<Vec<StepSource>> = Mutex::new(Vec::new());
|
||||
@@ -55,7 +62,8 @@ pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
|
||||
return;
|
||||
}
|
||||
let Ok(text) = std::fs::read_to_string(path) else { return };
|
||||
if !feature && !STEP_CALLS.iter().any(|call| text.contains(call)) {
|
||||
let calls: &[&str] = if is_python(path) { &PYTHON_STEP_CALLS } else { &STEP_CALLS };
|
||||
if !feature && !calls.iter().any(|call| text.contains(call)) {
|
||||
return;
|
||||
}
|
||||
let Ok(mut found) = found.lock() else { return };
|
||||
@@ -76,6 +84,7 @@ pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult<Vec<StepSource>>
|
||||
let mut excludes = project.search_excludes();
|
||||
// Cucumber's own sources (and every other package's) are not the project's steps.
|
||||
excludes.push("node_modules".to_owned());
|
||||
excludes.push("site-packages".to_owned());
|
||||
let mut out = Vec::new();
|
||||
for root in std::iter::once(project.root.clone()).chain(project.content_roots()) {
|
||||
out.extend(sources_in(&root, &excludes));
|
||||
@@ -104,11 +113,23 @@ mod tests {
|
||||
std::fs::write(root.join("src/CartSteps.java"), "@Given(\"an empty cart\")\npublic void empty() {}").unwrap();
|
||||
std::fs::write(root.join("src/App.java"), "class App {}").unwrap();
|
||||
std::fs::write(root.join("src/notes.md"), "Given('x')").unwrap();
|
||||
std::fs::write(root.join("steps/cart_steps.py"), "@given('an empty cart')\ndef step_impl(context): pass")
|
||||
.unwrap();
|
||||
std::fs::write(root.join("src/util.py"), "def given(x): return x\nWhen = given('x')").unwrap();
|
||||
std::fs::write(root.join("node_modules/@cucumber/cucumber/lib/index.js"), "Given('x')").unwrap();
|
||||
let files = sources_in(root, &["node_modules".to_owned()]);
|
||||
let names: Vec<String> =
|
||||
files.iter().map(|f| f.path.0.strip_prefix(root).unwrap().to_string_lossy().replace('\\', "/")).collect();
|
||||
assert_eq!(names, ["features/cart.feature", "src/CartSteps.java", "steps/bdd.mjs", "steps/cart.steps.ts"]);
|
||||
assert_eq!(
|
||||
names,
|
||||
[
|
||||
"features/cart.feature",
|
||||
"src/CartSteps.java",
|
||||
"steps/bdd.mjs",
|
||||
"steps/cart.steps.ts",
|
||||
"steps/cart_steps.py"
|
||||
]
|
||||
);
|
||||
assert!(files[0].feature && !files[1].feature);
|
||||
assert!(files[3].text.contains("an empty cart"));
|
||||
}
|
||||
|
||||
@@ -342,6 +342,11 @@ 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,
|
||||
@@ -834,6 +839,7 @@ ide_command::domain!(
|
||||
debug_listen_for_jvm,
|
||||
debug_pause,
|
||||
debug_redefine_classes,
|
||||
debug_resolve_variable,
|
||||
debug_restart_frame,
|
||||
debug_resume,
|
||||
debug_run_to,
|
||||
|
||||
@@ -13,6 +13,9 @@ const FILES: TableDefinition<&str, &[u8]> = TableDefinition::new("files");
|
||||
const META: TableDefinition<&str, &[u8]> = TableDefinition::new("meta");
|
||||
/// Bump when [`FileRecord`] or its encoding changes. 4: a symbol's base names.
|
||||
const SCHEMA: &str = "openidea-index-4";
|
||||
/// redb's page cache, which otherwise grows to 1 GiB. Queries run on the in-memory snapshot;
|
||||
/// the database is read once at startup and written incrementally.
|
||||
const DB_CACHE_BYTES: usize = 64 * 1024 * 1024;
|
||||
|
||||
/// The real Git directory for a checkout/worktree (`root/.git` may be a file
|
||||
/// containing `gitdir: ...`).
|
||||
@@ -389,7 +392,7 @@ impl Store {
|
||||
|
||||
fn open_db(&self) -> Result<Database> {
|
||||
let file = self.snapshot.with_file_name("index.redb");
|
||||
let db = match Database::create(&file) {
|
||||
let db = match Database::builder().set_cache_size(DB_CACHE_BYTES).create(&file) {
|
||||
Ok(db) => db,
|
||||
Err(redb::DatabaseError::DatabaseAlreadyOpen) => {
|
||||
return Err(format!("{} is in use", file.display()));
|
||||
@@ -398,7 +401,7 @@ impl Store {
|
||||
tracing::warn!("index cache {} unreadable ({e}); rebuilding", file.display());
|
||||
let _ = std::fs::remove_file(&file);
|
||||
let _ = std::fs::remove_file(&self.snapshot);
|
||||
Database::create(&file).map_err(err)?
|
||||
Database::builder().set_cache_size(DB_CACHE_BYTES).create(&file).map_err(err)?
|
||||
}
|
||||
};
|
||||
let valid = {
|
||||
|
||||
@@ -472,6 +472,8 @@ impl Shared {
|
||||
|
||||
fn full_scan(&self, found: Option<Vec<Found>>, guard: SystemTime) {
|
||||
self.scan(None, found, guard);
|
||||
// Parsing every file churns through far more memory than the index keeps.
|
||||
ide_core::memory::release_free_pages();
|
||||
}
|
||||
|
||||
fn scan(&self, dirs: Option<&[PathBuf]>, prewalked: Option<Vec<Found>>, guard: SystemTime) -> Option<ScanCounts> {
|
||||
|
||||
@@ -245,6 +245,11 @@ 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,6 +25,17 @@ 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 {
|
||||
@@ -97,22 +108,50 @@ 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 (server, generation, token) = (self.server.clone(), self.generation, token.clone());
|
||||
let (mgr, server, generation, token) = (self.mgr.clone(), 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 = match ¶ms["token"] {
|
||||
Value::String(s) => s.clone(),
|
||||
other => other.to_string(),
|
||||
};
|
||||
let token = progress_key(¶ms["token"]);
|
||||
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,12 +1049,14 @@ impl LspManager {
|
||||
if let Err(e) = peer.notify("initialized", json!({})) {
|
||||
tracing::warn!("{}: {e}", server.name);
|
||||
}
|
||||
// Servers that don't ask with `workspace/configuration` only learn settings this way.
|
||||
let cfg = server.effective_config();
|
||||
if cfg.settings.is_some()
|
||||
&& let Err(e) =
|
||||
peer.notify("workspace/didChangeConfiguration", json!({ "settings": handler::all_settings(&cfg) }))
|
||||
{
|
||||
// Sent even without settings: servers that don't ask with `workspace/configuration`
|
||||
// only learn settings this way, and Pyright, given workspace folders, waits for it
|
||||
// before asking and loading the workspace.
|
||||
let mut settings = handler::all_settings(&server.effective_config());
|
||||
if settings.is_null() {
|
||||
settings = json!({});
|
||||
}
|
||||
if let Err(e) = peer.notify("workspace/didChangeConfiguration", json!({ "settings": settings })) {
|
||||
tracing::debug!("{}: didChangeConfiguration: {e}", server.name);
|
||||
}
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
use ide_core::event::{LspRefreshKind, ServerStatus};
|
||||
use ide_core::{
|
||||
CancellationToken, DocId, FileEdit, IdeEvent, LanguageId, Pos, Range, ServerId, Severity, WorkspaceEdit,
|
||||
CancellationToken, DocId, FileEdit, IdeEvent, LanguageId, Pos, Range, ServerId, Severity, TaskId, WorkspaceEdit,
|
||||
};
|
||||
use ide_jsonrpc::{Handler, NoopHandler, Peer};
|
||||
use ide_language::{LanguageConfig, LanguageRegistry, LanguageServerConfig};
|
||||
@@ -1324,6 +1324,36 @@ async fn initialize_and_incremental_sync() {
|
||||
assert_eq!(infos[0].status, ServerStatus::Ready);
|
||||
}
|
||||
|
||||
/// Pyright, told the client has workspace folders, asks for its configuration and loads the
|
||||
/// workspace only after a `workspace/didChangeConfiguration`: every server gets one at startup.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn every_server_hears_its_configuration_once_initialized() {
|
||||
let cases = [
|
||||
(None, None, json!({})),
|
||||
(Some(json!({ "flag": true })), None, json!({ "flag": true })),
|
||||
(
|
||||
None,
|
||||
Some(json!({ "python": { "pythonPath": "/venv/bin/python" } })),
|
||||
json!({ "python": { "pythonPath": "/venv/bin/python" } }),
|
||||
),
|
||||
(Some(json!({ "flag": true })), Some(json!({ "other": 2 })), json!({ "flag": true, "other": 2 })),
|
||||
];
|
||||
for (init, settings, expected) in cases {
|
||||
let h = harness_configured("mock", "mk", &[("pyright", incremental_caps())], |cfg| {
|
||||
cfg.initialization_options = init.clone().map(|v| toml::Value::try_from(v).unwrap());
|
||||
cfg.settings = settings.clone();
|
||||
});
|
||||
h.open("a.mk", "x");
|
||||
h.wait_status("pyright", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("pyright");
|
||||
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
|
||||
assert_eq!(s.notified("workspace/didChangeConfiguration"), vec![json!({ "settings": expected })]);
|
||||
let order: Vec<String> = s.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
|
||||
let at = |m: &str| order.iter().position(|n| n == m).unwrap();
|
||||
assert!(at("initialized") < at("workspace/didChangeConfiguration"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn full_sync_and_desync_recovery() {
|
||||
let h = harness(&[("full", json!({ "textDocumentSync": 1 })), ("inc", json!({ "textDocumentSync": 2 }))]);
|
||||
@@ -2152,6 +2182,51 @@ 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())]);
|
||||
@@ -2650,7 +2725,16 @@ async fn configuration_answer_resyncs_open_documents_of_opted_in_servers() {
|
||||
.await;
|
||||
assert_eq!(s.notified("textDocument/didChange").len(), 2, "one re-sync per answer");
|
||||
let methods: Vec<String> = extra.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
|
||||
assert_eq!(methods, ["initialized", "textDocument/didOpen", "textDocument/didChange", "textDocument/didSave"]);
|
||||
assert_eq!(
|
||||
methods,
|
||||
[
|
||||
"initialized",
|
||||
"workspace/didChangeConfiguration",
|
||||
"textDocument/didOpen",
|
||||
"textDocument/didChange",
|
||||
"textDocument/didSave"
|
||||
]
|
||||
);
|
||||
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
@@ -2706,9 +2790,9 @@ async fn settings_changes_reach_servers_without_restarts() {
|
||||
let s = h.launcher.state("mock");
|
||||
*settings.lock() = Some(json!({ "nested": { "other": 2 } }));
|
||||
h.mgr.reconfigure().await;
|
||||
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
|
||||
eventually(|| s.notified("workspace/didChangeConfiguration").len() == 2).await;
|
||||
assert_eq!(
|
||||
s.notified("workspace/didChangeConfiguration")[0],
|
||||
s.notified("workspace/didChangeConfiguration")[1],
|
||||
json!({ "settings": { "flag": true, "nested": { "deep": 1, "other": 2 } } })
|
||||
);
|
||||
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
|
||||
|
||||
@@ -462,35 +462,54 @@ fn main() {
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires ty on PATH"]
|
||||
async fn ty_python_end_to_end() {
|
||||
python_server_end_to_end("ty").await;
|
||||
}
|
||||
|
||||
/// Pyright loads the workspace only after `workspace/didChangeConfiguration`.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires pyright-langserver on PATH"]
|
||||
async fn pyright_python_end_to_end() {
|
||||
python_server_end_to_end("pyright").await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires basedpyright on PATH"]
|
||||
async fn basedpyright_python_end_to_end() {
|
||||
python_server_end_to_end("basedpyright").await;
|
||||
}
|
||||
|
||||
/// Definition and diagnostics from `name` alone, in a project without configuration.
|
||||
async fn python_server_end_to_end(name: &str) {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path().canonicalize().unwrap();
|
||||
let path = root.join("example.py");
|
||||
let source = "def greet(name: str) -> str:\n return name\n\nresult = greet('Ada')\nbad: int = 'wrong'\n";
|
||||
std::fs::write(&path, source).unwrap();
|
||||
let mut python = LanguageRegistry::load(None).unwrap().get(&LanguageId::new("python")).unwrap();
|
||||
python.language_servers.retain(|server| server.name == "ty");
|
||||
python.language_servers.retain(|server| server.name == name);
|
||||
assert_eq!(python.language_servers.len(), 1);
|
||||
python.language_servers[0].fallback = false;
|
||||
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![python]));
|
||||
let doc = DocId::next();
|
||||
mgr.did_open(doc, &path, &LanguageId::new("python"), 1, source);
|
||||
retry("ty ready", Duration::from_secs(30), || {
|
||||
let status = last_status(&events, "ty");
|
||||
retry(&format!("{name} ready"), Duration::from_secs(30), || {
|
||||
let status = last_status(&events, name);
|
||||
if let Some((ServerStatus::Crashed | ServerStatus::Missing | ServerStatus::Misconfigured, msg)) = &status {
|
||||
panic!("ty failed: {msg:?}");
|
||||
panic!("{name} failed: {msg:?}");
|
||||
}
|
||||
async move { matches!(status, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }
|
||||
})
|
||||
.await;
|
||||
let defs = retry("ty definition", Duration::from_secs(30), || {
|
||||
let defs = retry(&format!("{name} definition"), Duration::from_secs(30), || {
|
||||
let mgr = mgr.clone();
|
||||
async move { mgr.goto(doc, Pos::new(3, 10), GotoKind::Definition).await.ok().filter(|d| !d.is_empty()) }
|
||||
})
|
||||
.await;
|
||||
assert_eq!(defs[0].path, path);
|
||||
assert_eq!(defs[0].range.start.line, 0);
|
||||
retry("ty diagnostics", Duration::from_secs(30), || {
|
||||
retry(&format!("{name} diagnostics"), Duration::from_secs(30), || {
|
||||
let found = events.lock().iter().any(
|
||||
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == "ty" && !items.is_empty()),
|
||||
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == name && !items.is_empty()),
|
||||
);
|
||||
async move { found.then_some(()) }
|
||||
})
|
||||
|
||||
@@ -1649,7 +1649,7 @@ pub fn jvm_inspect_bundle(data_dir: &Path) -> Option<PathBuf> {
|
||||
install_bundle(
|
||||
data_dir,
|
||||
"jvm-inspect",
|
||||
"1.1.0",
|
||||
"1.1.1",
|
||||
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.0.jar"));
|
||||
assert_eq!(jar, dir.path().join("jvm-inspect-1.1.1.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,28 +197,62 @@ fn software_term(lower: &str) -> bool {
|
||||
.is_some_and(|w| ["s", "x", "z", "ch", "sh"].iter().any(|e| w.ends_with(e)) && plural_of(w))
|
||||
}
|
||||
|
||||
/// Words of a custom dictionary file: a plain word list or a Hunspell `.dic`
|
||||
/// (leading count line and `/FLAGS` ignored). Cached by modification time.
|
||||
fn dictionary_file(path: &Path) -> Arc<HashSet<String>> {
|
||||
type Cache = HashMap<PathBuf, (Option<SystemTime>, Arc<HashSet<String>>)>;
|
||||
static CACHE: OnceLock<Mutex<Cache>> = OnceLock::new();
|
||||
let modified = std::fs::metadata(path).and_then(|m| m.modified()).ok();
|
||||
let mut cache = CACHE.get_or_init(Default::default).lock();
|
||||
if let Some((at, words)) = cache.get(path)
|
||||
&& *at == modified
|
||||
{
|
||||
return words.clone();
|
||||
}
|
||||
let words: HashSet<String> = match std::fs::read_to_string(path) {
|
||||
Ok(text) => parse_word_list(&text),
|
||||
Err(e) => {
|
||||
tracing::debug!("custom dictionary {}: {e}", path.display());
|
||||
HashSet::new()
|
||||
/// A custom dictionary: a word list, or a Hunspell dictionary with its affix rules.
|
||||
enum CustomDictionary {
|
||||
Words(HashSet<String>),
|
||||
Hunspell(Box<spellbook::Dictionary>),
|
||||
}
|
||||
|
||||
impl CustomDictionary {
|
||||
/// Whether the lowercased `lower` is a word of it, in any case style.
|
||||
fn contains(&self, lower: &str) -> bool {
|
||||
match self {
|
||||
Self::Words(words) => words.contains(lower),
|
||||
Self::Hunspell(dict) => {
|
||||
dict.check(lower) || dict.check(&capitalize(lower)) || dict.check(&lower.to_uppercase())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The `.aff` next to a Hunspell `.dic` (`de_DE.dic` → `de_DE.aff`), if there is one.
|
||||
fn affix_file(path: &Path) -> Option<PathBuf> {
|
||||
if !path.extension().is_some_and(|e| e.eq_ignore_ascii_case("dic")) {
|
||||
return None;
|
||||
}
|
||||
["aff", "AFF"].into_iter().map(|ext| path.with_extension(ext)).find(|aff| aff.is_file())
|
||||
}
|
||||
|
||||
/// A custom dictionary file: a Hunspell `.dic` with the `.aff` beside it, with
|
||||
/// its affix, compounding and case rules; otherwise a plain word list (a `.dic`
|
||||
/// alone: leading count line and `/FLAGS` ignored). Cached by modification time.
|
||||
fn dictionary_file(path: &Path) -> Arc<CustomDictionary> {
|
||||
type Stamp = (Option<SystemTime>, Option<SystemTime>);
|
||||
type Cache = HashMap<PathBuf, (Stamp, Arc<CustomDictionary>)>;
|
||||
static CACHE: OnceLock<Mutex<Cache>> = OnceLock::new();
|
||||
let modified = |p: &Path| std::fs::metadata(p).and_then(|m| m.modified()).ok();
|
||||
let aff = affix_file(path);
|
||||
let stamp = (modified(path), aff.as_deref().and_then(modified));
|
||||
if let Some((at, dict)) = CACHE.get_or_init(Default::default).lock().get(path)
|
||||
&& *at == stamp
|
||||
{
|
||||
return dict.clone();
|
||||
}
|
||||
let read = |p: &Path| {
|
||||
std::fs::read_to_string(p).map_err(|e| tracing::debug!("custom dictionary {}: {e}", p.display())).ok()
|
||||
};
|
||||
let words = Arc::new(words);
|
||||
cache.insert(path.to_path_buf(), (modified, words.clone()));
|
||||
words
|
||||
let text = read(path).unwrap_or_default();
|
||||
let hunspell = aff.as_deref().and_then(read).and_then(|aff| {
|
||||
spellbook::Dictionary::new(&aff, &text)
|
||||
.map_err(|e| tracing::warn!("Hunspell dictionary {}: {e}", path.display()))
|
||||
.ok()
|
||||
});
|
||||
let dict = Arc::new(match hunspell {
|
||||
Some(dict) => CustomDictionary::Hunspell(Box::new(dict)),
|
||||
None => CustomDictionary::Words(parse_word_list(&text)),
|
||||
});
|
||||
CACHE.get_or_init(Default::default).lock().insert(path.to_path_buf(), (stamp, dict.clone()));
|
||||
dict
|
||||
}
|
||||
|
||||
/// Lowercased words of a word list / Hunspell `.dic` text.
|
||||
@@ -238,7 +272,7 @@ pub fn parse_word_list(text: &str) -> HashSet<String> {
|
||||
#[derive(Default)]
|
||||
pub struct Speller {
|
||||
accepted: HashSet<String>,
|
||||
custom: Vec<Arc<HashSet<String>>>,
|
||||
custom: Vec<Arc<CustomDictionary>>,
|
||||
}
|
||||
|
||||
impl Speller {
|
||||
@@ -351,16 +385,31 @@ impl Speller {
|
||||
&& !near_word(lower, |w| english().check(w))
|
||||
}
|
||||
|
||||
/// Replacements for `word`, best first, in the word's case style.
|
||||
/// Replacements for `word`, best first, in the word's case style: from the
|
||||
/// English dictionary and the custom Hunspell dictionaries, the closest first.
|
||||
pub fn suggest(&self, word: &str, limit: usize) -> Vec<String> {
|
||||
let hunspell = self.custom.iter().filter_map(|d| match d.as_ref() {
|
||||
CustomDictionary::Hunspell(dict) => Some(dict.as_ref()),
|
||||
CustomDictionary::Words(_) => None,
|
||||
});
|
||||
let dicts: Vec<&spellbook::Dictionary> = std::iter::once(english()).chain(hunspell).collect();
|
||||
let mut out = Vec::new();
|
||||
english().suggest(word, &mut out);
|
||||
if out.is_empty() && word.chars().next().is_some_and(char::is_uppercase) {
|
||||
english().suggest(&word.to_lowercase(), &mut out);
|
||||
out = out.into_iter().map(|s| capitalize(&s)).collect();
|
||||
for dict in &dicts {
|
||||
let mut found = Vec::new();
|
||||
dict.suggest(word, &mut found);
|
||||
if found.is_empty() && word.chars().next().is_some_and(char::is_uppercase) {
|
||||
dict.suggest(&word.to_lowercase(), &mut found);
|
||||
found = found.into_iter().map(|s| capitalize(&s)).collect();
|
||||
}
|
||||
out.extend(found);
|
||||
}
|
||||
let mut seen = HashSet::new();
|
||||
out.retain(|s| s != word && seen.insert(s.clone()));
|
||||
if dicts.len() > 1 {
|
||||
// Stable: within a distance each dictionary keeps its own order, English first.
|
||||
let lower = word.to_lowercase();
|
||||
out.sort_by_key(|s| edit_distance(&lower, &s.to_lowercase()));
|
||||
}
|
||||
out.truncate(limit);
|
||||
out
|
||||
}
|
||||
@@ -416,6 +465,22 @@ impl Speller {
|
||||
}
|
||||
}
|
||||
|
||||
/// Levenshtein distance in characters.
|
||||
fn edit_distance(a: &str, b: &str) -> usize {
|
||||
let b: Vec<char> = b.chars().collect();
|
||||
let mut row: Vec<usize> = (0..=b.len()).collect();
|
||||
for (i, ca) in a.chars().enumerate() {
|
||||
let mut diagonal = row[0];
|
||||
row[0] = i + 1;
|
||||
for (j, cb) in b.iter().enumerate() {
|
||||
let next = (row[j + 1] + 1).min(row[j] + 1).min(diagonal + usize::from(ca != *cb));
|
||||
diagonal = row[j + 1];
|
||||
row[j + 1] = next;
|
||||
}
|
||||
}
|
||||
row[b.len()]
|
||||
}
|
||||
|
||||
fn capitalize(s: &str) -> String {
|
||||
let mut chars = s.chars();
|
||||
chars.next().into_iter().flat_map(char::to_uppercase).chain(chars).collect()
|
||||
@@ -736,6 +801,36 @@ mod tests {
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hunspell_custom_dictionaries_use_their_affix_rules() {
|
||||
let dir = std::env::temp_dir().join(format!("ide-spell-hunspell-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let dic = dir.join("de_TEST.dic");
|
||||
std::fs::write(&dic, "3\nhaus/NZ\ntür/NZ\nschlüssel/Z\n").unwrap();
|
||||
std::fs::write(
|
||||
dir.join("de_TEST.aff"),
|
||||
"SET UTF-8\nTRY esianrtolcdugmphbyfvkwzäöüß\nCOMPOUNDFLAG Z\nSFX N Y 1\nSFX N 0 en .\n",
|
||||
)
|
||||
.unwrap();
|
||||
let s = Speller::new::<&str>([], std::slice::from_ref(&dic));
|
||||
// Affix rules, compounds and case styles of the .aff, not just the listed stems.
|
||||
for word in ["haus", "Haus", "hausen", "türen", "Haustür", "schlüsselhaus"] {
|
||||
assert!(s.is_correct(word), "{word}");
|
||||
}
|
||||
assert!(!s.is_correct("hauz"));
|
||||
assert!(!s.is_correct("schlüsselen"));
|
||||
assert!(s.suggest("Hauss", 5).iter().any(|w| w == "Haus"), "{:?}", s.suggest("Hauss", 5));
|
||||
// English still checks and suggests.
|
||||
assert!(s.is_correct("message"));
|
||||
assert!(s.suggest("mesage", 5).iter().any(|w| w == "message"));
|
||||
// Without its .aff, a .dic is a word list.
|
||||
std::fs::remove_file(dir.join("de_TEST.aff")).unwrap();
|
||||
let words = Speller::new::<&str>([], std::slice::from_ref(&dic));
|
||||
assert!(words.is_correct("haus"));
|
||||
assert!(!words.is_correct("hausen"));
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn utf16_ranges() {
|
||||
let s = Speller::default();
|
||||
|
||||
@@ -372,6 +372,8 @@ fn materialize_row(
|
||||
if let Some((pos, total)) = position {
|
||||
commit.log_position = Some(pos);
|
||||
commit.log_total = Some(total);
|
||||
let merge_time_ms = row.merge_time_secs as f64 * 1000.0;
|
||||
commit.log_merge_time_ms = (merge_time_ms > commit.commit_time_ms).then_some(merge_time_ms);
|
||||
}
|
||||
if !summary_only {
|
||||
commit.message = index.message(repo, row.id)?;
|
||||
@@ -714,17 +716,16 @@ fn log_indexed_rows(
|
||||
skip -= 1;
|
||||
continue;
|
||||
}
|
||||
let parents: Vec<ObjectId> = if shallow.contains(&id) {
|
||||
Vec::new()
|
||||
} else if let Some((ps, _)) = visibility.index.nodes.get(&id) {
|
||||
ps.clone()
|
||||
let (parents, commit_time_secs) = if let Some((parents, time)) = visibility.index.nodes.get(&id) {
|
||||
(parents.clone(), *time)
|
||||
} else {
|
||||
let record = visibility.index.get_with_table(&repo, id, visibility.table)?;
|
||||
record
|
||||
let parents = record
|
||||
.parents
|
||||
.iter()
|
||||
.map(|p| ObjectId::from_hex(p.as_bytes()).map_err(gx))
|
||||
.collect::<IdeResult<Vec<_>>>()?
|
||||
.collect::<IdeResult<Vec<_>>>()?;
|
||||
(parents, (record.commit_time_ms / 1000.0) as i64)
|
||||
};
|
||||
let shown_parents = if shallow.contains(&id) {
|
||||
Vec::new()
|
||||
@@ -743,6 +744,7 @@ fn log_indexed_rows(
|
||||
graph_parents: shown_parents,
|
||||
on_current_branch,
|
||||
history_path: history_paths.get(&id).cloned(),
|
||||
merge_time_secs: commit_time_secs,
|
||||
});
|
||||
if out.len() >= limit || stop_id == Some(id) {
|
||||
break;
|
||||
|
||||
@@ -125,6 +125,9 @@ pub struct Commit {
|
||||
pub log_position: Option<u32>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub log_total: Option<u32>,
|
||||
/// Newest committer time at or after this row if newer than the row's commit.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub log_merge_time_ms: Option<f64>,
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub graph_boundary_parents: Vec<String>,
|
||||
/// Reachability from HEAD, computed independently of the visible filters.
|
||||
|
||||
@@ -19,12 +19,16 @@ const MESSAGES: TableDefinition<&str, &str> = TableDefinition::new("messages-v1"
|
||||
const MAX_MEMORY_COMMITS: usize = 4096;
|
||||
const MAX_MEMORY_MESSAGES: usize = 1024;
|
||||
const MAX_DIRTY_BATCH: usize = 16_384;
|
||||
/// redb's page cache, which otherwise grows to 1 GiB per repository. Hot commits are already
|
||||
/// kept in `memory`.
|
||||
const DB_CACHE_BYTES: usize = 32 * 1024 * 1024;
|
||||
|
||||
pub(crate) struct IndexedRow {
|
||||
pub id: ObjectId,
|
||||
pub graph_parents: Vec<ObjectId>,
|
||||
pub on_current_branch: bool,
|
||||
pub history_path: Option<String>,
|
||||
pub merge_time_secs: i64,
|
||||
}
|
||||
|
||||
pub(crate) struct IndexedView {
|
||||
@@ -32,8 +36,15 @@ pub(crate) struct IndexedView {
|
||||
pub positions: HashMap<ObjectId, usize>,
|
||||
}
|
||||
impl IndexedView {
|
||||
pub fn new(rows: Vec<IndexedRow>) -> Self {
|
||||
let positions = rows.iter().enumerate().map(|(i, r)| (r.id, i)).collect();
|
||||
pub fn new(mut rows: Vec<IndexedRow>) -> Self {
|
||||
let mut positions = HashMap::with_capacity(rows.len());
|
||||
let mut latest = i64::MIN;
|
||||
// Compute priority across the whole log so it stays the same on every page.
|
||||
for (i, row) in rows.iter_mut().enumerate().rev() {
|
||||
latest = latest.max(row.merge_time_secs);
|
||||
row.merge_time_secs = latest;
|
||||
positions.insert(row.id, i);
|
||||
}
|
||||
Self { rows, positions }
|
||||
}
|
||||
}
|
||||
@@ -269,7 +280,11 @@ impl LogIndex {
|
||||
let path = dir.join("commits.redb");
|
||||
let mut databases = DATABASES.get_or_init(Mutex::default).lock().unwrap_or_else(|p| p.into_inner());
|
||||
self.db = databases.get(&path).and_then(Weak::upgrade).or_else(|| {
|
||||
let db = Arc::new(std::fs::create_dir_all(dir).ok().and_then(|_| Database::create(&path).ok())?);
|
||||
let db = Arc::new(
|
||||
std::fs::create_dir_all(dir)
|
||||
.ok()
|
||||
.and_then(|_| Database::builder().set_cache_size(DB_CACHE_BYTES).create(&path).ok())?,
|
||||
);
|
||||
drop_stale_tables(&db);
|
||||
databases.insert(path, Arc::downgrade(&db));
|
||||
Some(db)
|
||||
@@ -334,6 +349,7 @@ impl LogIndex {
|
||||
history_path: None,
|
||||
log_position: None,
|
||||
log_total: None,
|
||||
log_merge_time_ms: None,
|
||||
graph_boundary_parents: Vec::new(),
|
||||
refs: Vec::new(),
|
||||
});
|
||||
|
||||
@@ -1155,16 +1155,31 @@ 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 = check_rev(branch)?;
|
||||
let branch = unambiguous_branch_name(r, 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 = check_rev(onto)?;
|
||||
let onto = unambiguous_branch_name(r, check_rev(onto)?);
|
||||
crate::preserve::around(r, "Local changes saved before rebase", || {
|
||||
run(r.root(), &["rebase", onto], None).map(|_| ())
|
||||
})
|
||||
|
||||
@@ -505,6 +505,37 @@ 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,6 +83,28 @@ fn incoming_order_groups_the_merged_branch_before_the_main_parent() {
|
||||
assert_eq!(out[1].parents, vec![h.c2.clone(), h.s1.clone()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_older_incoming_tip_uses_the_later_commit_time_when_merging_repo_pages() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let dir = tmp.path();
|
||||
git(dir, &["init", "-q"], None);
|
||||
let base = commit(dir, "base.txt", "base", 1000);
|
||||
let recent = commit(dir, "recent.txt", "recent", 4000);
|
||||
git(dir, &["checkout", "-qb", "incoming", &base], None);
|
||||
let incoming = commit(dir, "incoming.txt", "incoming", 2000);
|
||||
git(dir, &["checkout", "-q", "main"], None);
|
||||
let repo = Repo::discover(dir).unwrap().unwrap();
|
||||
let query = LogQuery { summary_only: true, order: LogOrder::Standard, limit: 1, ..Default::default() };
|
||||
|
||||
let first = repo.log(&query).unwrap();
|
||||
assert_eq!(first[0].id, incoming);
|
||||
assert_eq!(first[0].commit_time_ms, 2_000_000.0);
|
||||
assert_eq!(first[0].log_merge_time_ms, Some(4_000_000.0));
|
||||
let next = repo.log(&LogQuery { skip: 1, ..query }).unwrap();
|
||||
assert_eq!(next[0].id, recent);
|
||||
assert_eq!(next[0].log_merge_time_ms, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_merges_links_children_to_the_merge_parents() {
|
||||
let h = history();
|
||||
|
||||
@@ -86,6 +86,7 @@ Each crate's `lib.rs` opens with a module doc comment describing its contract; r
|
||||
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `ide-cli` | The `openidea` command: argument parsing, the request it sends to a running app over a local socket, installing it on `PATH`. |
|
||||
| `ide-clipboard` | The OS clipboard's file list (Windows `CF_HDROP`, macOS `NSPasteboard` file URLs) for copying files between the Project view and the file manager. |
|
||||
| `ide-drag-out` | OS file drags out of a window (GTK, OLE, AppKit), so files dragged from the Project view to another app are copied there. |
|
||||
| `ide-fonts` | Installed font families for the font pickers, via CoreText, DirectWrite or fontconfig. |
|
||||
| `src-tauri` (package `openidea`) | The desktop shell: `AppState`, Tauri commands, the event sink, windows, menus, the remote-development client, the `openidea-plugin` URL scheme for plugin web views. Glue only. |
|
||||
|
||||
|
||||
@@ -125,7 +125,7 @@ Tasks are saved per project and survive restarts. When the agent supports resumi
|
||||
|
||||
**Settings › Tools › Agents** (also **More Agents…** in the agent picker) has two tabs:
|
||||
|
||||
- **Built-in**: for each built-in agent, whether its executable was found on `PATH`, a field to point at a **Custom executable**, **Environment variables** for the agent process (written as `NAME=value; OTHER=value`; the values are kept in the OS credential store) and how to sign in. Changes apply to new sessions.
|
||||
- **Built-in**: for each built-in agent, whether its executable was found on `PATH`, a field to point at a **Custom executable**, **Environment variables** for the agent process (written as `NAME=value; OTHER=value`; the values are kept in the OS credential store) and how to sign in. Changes apply to new sessions. When the agent is a global npm install (such as Claude Code, Codex or Gemini CLI), **Check for updates** compares it with npm's latest stable release and **Update to…** updates that installation.
|
||||
- **ACP Registry**: agents published in the [ACP Registry](https://agentclientprotocol.com). Search, **Install**, **Update** and **Remove**. Installed agents are kept in OpenIDEA's data directory; downloads are checked against the registry's SHA-256 when it provides one.
|
||||
|
||||
**Settings › Tools › Agents › Chat** chooses what the task header shows: **Context window usage**, **Time spent on the task**, **Usage limits** (when the agent reports them, such as Claude Code) and **Session cost**.
|
||||
|
||||
@@ -172,11 +172,13 @@ The export button offers **Export Data…** and quick copies: **Copy as CSV**, *
|
||||
|
||||
The built-in HTTP driver uses a named session by default (`use_http_session=true`). Route requests to one node or enable session affinity. If the session expires or another node reports code 372, OpenIDEA shows a reconnect error and never replays the statement.
|
||||
|
||||
For endpoints that route each request to a different node, add **Advanced** property `use_http_session` with value `false`. Each request omits `session_id`, `session_check` and `session_timeout`, and sends the configured database (or **Default schema**), time zone and Advanced settings again. **Read-only** sends `readonly=1` on every request; result-limit settings remain enabled.
|
||||
For endpoints that route each request to a different node, add **Advanced** property `use_http_session` with value `false`. Each request omits `session_id`, `session_check` and `session_timeout`, and sends the configured database (or **Default schema**), time zone and Advanced settings again. **Read-only** sends `readonly=1` on every request.
|
||||
|
||||
Stateless statements must be independent: `USE`, standalone `SET`, temporary tables and other session state cannot carry over to later requests. Configure the database and settings on the data source. Startup scripts and explicit session properties (`session_id`, `session_check`, `session_timeout`) are rejected. SQL transactions and statement caching are unsupported in either mode.
|
||||
|
||||
Strict read-only servers that refuse per-request driver settings cannot use stateless mode: the connection fails without dropping read-only protection or limits. The strict read-only fallback requires proof in the same named HTTP session, including on subsequent requests; use one node or session affinity.
|
||||
For strict read-only accounts behind a load balancer, set `use_http_session=false` and enable **Read-only**. If the initial connection check receives ClickHouse code 164 for a driver-managed result setting, OpenIDEA repeats the check without its result-limit and JSON number-format settings. Each request still sends `readonly=1`, and the grid still retains only the requested page. Configure server-side limits in the account's settings profile. With the server's default JSON settings, `NaN` and infinities may appear as `NULL`.
|
||||
|
||||
Use consistent account profiles across replicas. If the first node accepts the driver's result settings and a later node rejects them, OpenIDEA reports the error on that request. Connect again after aligning the profiles.
|
||||
|
||||
## Oracle
|
||||
|
||||
|
||||
@@ -112,7 +112,7 @@ The debugger adds attach-only types such as **Remote JVM Debug**, **Go Remote**,
|
||||
### Common fields
|
||||
|
||||
- **Run on**: the local machine, or an SSH host defined in **Settings › Build, Execution, Deployment › Run Targets**. Debugging is not available on run targets. See [SSH](/en/guide/remote/ssh).
|
||||
- **Working directory**: relative to the project root; empty means the project root.
|
||||
- **Working directory**: relative to the project root; empty means the project root. It may use the path macros `$PROJECT_DIR$`, `$ContentRoot$`, `$MODULE_DIR$`, `$MODULE_WORKING_DIR$` and `$USER_HOME$`, expanded when the configuration starts, so a shared configuration works on every machine.
|
||||
- **Environment variables**: `VAR=value` pairs separated by `;`. The list button opens the **Environment Variables** dialog, where **Include system environment variables** can be turned off.
|
||||
- **Debug adapter**: which debugger **Debug** uses for this configuration (for example `debugpy`, `js-debug`, `codelldb`, `delve`).
|
||||
|
||||
|
||||
@@ -86,6 +86,7 @@ Cargo workspace 由 `crates/*` 加 `src-tauri` 组成(见根目录 `Cargo.toml
|
||||
| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `ide-cli` | `openidea` 命令:参数解析、通过本地 socket 发给运行中应用的请求、安装到 `PATH`。 |
|
||||
| `ide-clipboard` | 操作系统剪贴板里的文件列表(Windows `CF_HDROP`、macOS `NSPasteboard` 文件 URL),用于 Project 视图与文件管理器之间复制文件。 |
|
||||
| `ide-drag-out` | 从窗口发起操作系统文件拖放(GTK、OLE、AppKit),从 Project 视图拖到其他程序的文件由该程序复制。 |
|
||||
| `ide-fonts` | 已安装的字体族,供字体选择器使用,分别通过 CoreText、DirectWrite 或 fontconfig 获取。 |
|
||||
| `src-tauri`(包名 `openidea`) | 桌面外壳:`AppState`、Tauri 命令、事件 sink、窗口、菜单、远程开发客户端、插件 Web 视图用的 `openidea-plugin` URL scheme。只做胶水。 |
|
||||
|
||||
|
||||
@@ -125,7 +125,7 @@ agent 运行过一个任务后,新任务会以它自动批准所有操作的
|
||||
|
||||
**设置 › 工具 › 智能体**(也可以在 agent 选择器中点 **更多 Agent…**)有两个标签页:
|
||||
|
||||
- **内置**:每个内置 agent 的可执行文件是否在 `PATH` 中找到、指定 **自定义可执行文件** 的输入框、传给 agent 进程的 **环境变量**(格式为 `NAME=value; OTHER=value`;这些值保存在系统凭据存储中)以及登录方式。改动对新会话生效。
|
||||
- **内置**:每个内置 agent 的可执行文件是否在 `PATH` 中找到、指定 **自定义可执行文件** 的输入框、传给 agent 进程的 **环境变量**(格式为 `NAME=value; OTHER=value`;这些值保存在系统凭据存储中)以及登录方式。改动对新会话生效。如果 agent 是 npm 全局安装(例如 Claude Code、Codex、Gemini CLI),**检查更新** 会与 npm 的最新稳定版比较,点击 **更新至…** 即可更新这份安装。
|
||||
- **ACP 注册表**:[ACP Registry](https://agentclientprotocol.com) 中发布的 agent,可以搜索、**安装**、**更新** 和 **移除**。安装的 agent 保存在 OpenIDEA 的数据目录中;注册表提供 SHA-256 时会校验下载内容。
|
||||
|
||||
**设置 › 工具 › 智能体 › 聊天** 决定任务标题栏显示哪些信息:**上下文窗口用量**、**任务耗时**、**用量限额**(agent 报告时,例如 Claude Code)和 **会话花费**。
|
||||
|
||||
@@ -171,11 +171,13 @@ SQL 补全基于已连接的架构:`FROM`/`JOIN` 后补全表(并根据外
|
||||
|
||||
内置 HTTP 驱动默认使用命名会话(`use_http_session=true`)。请求应路由到同一节点,或启用会话亲和性。如果会话过期或其他节点返回代码 372,OpenIDEA 会提示重新连接,且不会重放语句。
|
||||
|
||||
如果端点把每个请求路由到不同节点,可在 **高级** 中添加属性 `use_http_session`,值设为 `false`。每个请求都省略 `session_id`、`session_check` 和 `session_timeout`,并重新发送配置的数据库(或 **默认架构**)、时区及高级设置。启用 **只读** 时,每个请求都发送 `readonly=1`;结果行数限制设置也会保留。
|
||||
如果端点把每个请求路由到不同节点,可在 **高级** 中添加属性 `use_http_session`,值设为 `false`。每个请求都省略 `session_id`、`session_check` 和 `session_timeout`,并重新发送配置的数据库(或 **默认架构**)、时区及高级设置。启用 **只读** 时,每个请求都发送 `readonly=1`。
|
||||
|
||||
无会话模式下,每条语句必须独立:`USE`、独立的 `SET`、临时表及其他会话状态无法延续到后续请求。请在数据源中配置数据库和设置。驱动会拒绝启动脚本以及显式会话属性(`session_id`、`session_check`、`session_timeout`)。两种模式均不支持 SQL 事务和语句缓存。
|
||||
|
||||
拒绝逐请求驱动设置的严格只读服务器无法使用无会话模式:连接会失败,不会移除只读保护或限制。严格只读回退必须在同一个命名 HTTP 会话中验证,后续请求也必须使用该会话;请使用单一节点或会话亲和性。
|
||||
对于负载均衡器后的严格只读账户,请设置 `use_http_session=false` 并启用 **只读**。如果初次连接检查因驱动管理的结果设置收到 ClickHouse 错误码 164,OpenIDEA 会省略驱动的结果行数限制和 JSON 数字格式设置,再进行一次连接检查。每个请求仍会发送 `readonly=1`,结果表格仍只保留所请求的一页。请在账户的设置配置文件中配置服务端限制。使用服务器的默认 JSON 设置时,`NaN` 和无穷值可能显示为 `NULL`。
|
||||
|
||||
请在各副本上使用一致的账户设置配置文件。如果第一个节点接受驱动的结果设置,后续节点拒绝这些设置,OpenIDEA 会报告该请求的错误。调整配置文件使其一致后再连接。
|
||||
|
||||
## Oracle
|
||||
|
||||
|
||||
@@ -108,7 +108,7 @@ description: "创建、编辑和启动运行配置,从装订区运行代码,
|
||||
### 通用字段
|
||||
|
||||
- **运行于**:本地计算机,或在 **设置 › 构建、执行、部署 › 运行目标** 中添加的 SSH 主机。运行目标上不支持调试。参见 [SSH](/zh/guide/remote/ssh)。
|
||||
- **工作目录**:相对于项目根目录,留空即项目根目录。
|
||||
- **工作目录**:相对于项目根目录,留空即项目根目录。可以使用路径宏 `$PROJECT_DIR$`、`$ContentRoot$`、`$MODULE_DIR$`、`$MODULE_WORKING_DIR$` 和 `$USER_HOME$`,在配置启动时展开,因此共享的配置在每台机器上都能用。
|
||||
- **环境变量**:`VAR=value` 形式,用 `;` 分隔。点旁边的列表按钮打开“环境变量”对话框,可以关闭 **包括系统环境变量**。
|
||||
- **调试适配器**:按“调试”时这个配置使用哪个调试器(如 `debugpy`、`js-debug`、`codelldb`、`delve`)。
|
||||
|
||||
|
||||
@@ -0,0 +1,88 @@
|
||||
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();
|
||||
});
|
||||
@@ -0,0 +1,85 @@
|
||||
import type { AgentEntry, AgentTask } from "../src/bindings";
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
const first: AgentTask = {
|
||||
id: "context-first",
|
||||
title: "First conversation",
|
||||
provider: "codex",
|
||||
status: "ready",
|
||||
isolation: "local",
|
||||
model: null,
|
||||
cwd: "/dev/acme-api",
|
||||
branch: null,
|
||||
base: null,
|
||||
baseCommit: null,
|
||||
error: null,
|
||||
createdMs: 0,
|
||||
updatedMs: 0,
|
||||
config: [],
|
||||
commands: [],
|
||||
usage: null,
|
||||
queue: [],
|
||||
};
|
||||
const second: AgentTask = { ...first, id: "context-second", title: "Second conversation" };
|
||||
|
||||
for (const active of ["conversation", "file"] as const) {
|
||||
test(`an agent context menu keeps the current ${active} open`, async ({ workbench: page }) => {
|
||||
await page.getByRole("treeitem", { name: "README.md", exact: true }).dblclick();
|
||||
await expect(page.getByRole("tab", { name: "README.md", exact: true })).toBeVisible();
|
||||
await page.evaluate(
|
||||
async ({ first, second }) => {
|
||||
const storePath = "/src/features/agents/store.ts";
|
||||
const ipcPath = "/src/platform/ipc.ts";
|
||||
const contributionsPath = "/src/workbench/contributions.ts";
|
||||
const store = await import(storePath);
|
||||
const { commands } = await import(ipcPath);
|
||||
const { toolWindowService } = await import(contributionsPath);
|
||||
commands.agentChanges = async () => ({ status: "ok", data: [] });
|
||||
const entries: AgentEntry[] = [{ type: "agent", text: "The active conversation stays here." }];
|
||||
store.useAgents.setState({
|
||||
loaded: true,
|
||||
error: null,
|
||||
providers: [],
|
||||
tasks: new Map([
|
||||
[first.id, first],
|
||||
[second.id, second],
|
||||
]),
|
||||
entries: new Map([
|
||||
[first.id, entries],
|
||||
[second.id, []],
|
||||
]),
|
||||
composers: new Map([[first.id, { text: "Keep this unsent draft", files: [], images: [] }]]),
|
||||
unread: new Set(),
|
||||
docked: null,
|
||||
homeOpen: false,
|
||||
sessionLocation: "editor",
|
||||
});
|
||||
toolWindowService().show("agents", true);
|
||||
store.openTask(first.id);
|
||||
},
|
||||
{ first, second },
|
||||
);
|
||||
const firstTab = page.getByRole("tab", { name: first.title, exact: true });
|
||||
const fileTab = page.getByRole("tab", { name: "README.md", exact: true });
|
||||
await expect(firstTab).toHaveAttribute("aria-selected", "true");
|
||||
if (active === "file") await fileTab.click();
|
||||
const current = active === "file" ? fileTab : firstTab;
|
||||
const target = page.getByRole("tree", { name: "Agent tasks" }).getByText(second.title, { exact: true });
|
||||
await target.click({ button: "right" });
|
||||
await expect(page.getByRole("menuitem", { name: "Rename…", exact: true })).toBeVisible();
|
||||
await expect(current).toHaveAttribute("aria-selected", "true");
|
||||
await expect(page.getByRole("tab", { name: second.title, exact: true })).toHaveCount(0);
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(current).toHaveAttribute("aria-selected", "true");
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(async (id) => {
|
||||
const storePath = "/src/features/agents/store.ts";
|
||||
return (await import(storePath)).composerDraft(id).text;
|
||||
}, first.id),
|
||||
)
|
||||
.toBe("Keep this unsent draft");
|
||||
await target.click();
|
||||
await expect(page.getByRole("tab", { name: second.title, exact: true })).toHaveAttribute("aria-selected", "true");
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
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();
|
||||
});
|
||||
@@ -0,0 +1,71 @@
|
||||
import { expect, openFromTree, test } from "./fixtures";
|
||||
|
||||
test("code folding controls stay grouped in narrow settings", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Code Folding");
|
||||
await dialog.getByRole("treeitem", { name: "Code Folding", exact: true }).click();
|
||||
|
||||
const label = "Show code folding outline";
|
||||
const outline = dialog.getByRole("checkbox", { name: label, exact: true });
|
||||
const visibility = dialog.getByRole("button", { name: label, exact: true });
|
||||
const defaults = dialog.getByRole("region", { name: "Fold by default:", exact: true });
|
||||
await expect(visibility).toHaveText("On hover");
|
||||
const wideOutline = (await outline.boundingBox())!;
|
||||
expect((await visibility.boundingBox())!.x).toBeGreaterThan(wideOutline.x + wideOutline.width);
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
await expect(visibility).toBeInViewport({ ratio: 0.98 });
|
||||
const rows = await Promise.all(
|
||||
["File header", "Imports", "Documentation comments"].map((name) =>
|
||||
defaults.getByRole("checkbox", { name, exact: true }).boundingBox(),
|
||||
),
|
||||
);
|
||||
expect(rows[0]!.x).toBe(rows[2]!.x);
|
||||
expect(rows[0]!.y).toBeLessThan(rows[1]!.y);
|
||||
expect(rows[1]!.y).toBeLessThan(rows[2]!.y);
|
||||
|
||||
await outline.uncheck();
|
||||
await expect(dialog.getByRole("textbox", { name: label, exact: true })).toBeDisabled();
|
||||
await expect(defaults.getByRole("checkbox", { name: "Imports", exact: true })).toBeEnabled();
|
||||
});
|
||||
|
||||
test("folding visibility applies to an already open editor and keeps folded arrows visible", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const editor = await openFromTree(page, "App.tsx");
|
||||
const content = editor.locator(".cm-content");
|
||||
await content.click();
|
||||
await page.keyboard.press("Meta+a");
|
||||
await page.keyboard.insertText("export function sum() {\n return 1 + 2;\n}\n");
|
||||
const arrow = editor.locator(".cm-foldGutter .cm-openidea-foldOpen").first();
|
||||
await expect(arrow).toHaveCSS("opacity", "0");
|
||||
|
||||
const openSettings = async () => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Code Folding");
|
||||
await dialog.getByRole("treeitem", { name: "Code Folding", exact: true }).click();
|
||||
return dialog;
|
||||
};
|
||||
const label = "Show code folding outline";
|
||||
const settings = await openSettings();
|
||||
await settings.getByRole("button", { name: label, exact: true }).click();
|
||||
await page.getByRole("option", { name: "Always", exact: true }).click();
|
||||
await settings.getByRole("button", { name: "OK", exact: true }).click();
|
||||
await content.hover();
|
||||
await expect(arrow).toHaveCSS("opacity", "1");
|
||||
|
||||
const reopened = await openSettings();
|
||||
const control = reopened.getByRole("button", { name: label, exact: true });
|
||||
await expect(control).toHaveText("Always");
|
||||
await control.click();
|
||||
await page.getByRole("option", { name: "On hover", exact: true }).click();
|
||||
await reopened.getByRole("button", { name: "OK", exact: true }).click();
|
||||
await content.hover();
|
||||
await expect(arrow).toHaveCSS("opacity", "0");
|
||||
await arrow.click();
|
||||
await content.hover();
|
||||
await expect(editor.locator(".cm-foldGutter .cm-openidea-foldClosed").first()).toHaveCSS("opacity", "1");
|
||||
await expect(editor.locator(".cm-foldPlaceholder").first()).toBeVisible();
|
||||
});
|
||||
@@ -60,7 +60,21 @@ test("completion lists the server's items and inserts the chosen one", async ({
|
||||
await editor.locator(".cm-line", { hasText: "return order.toDto()" }).click();
|
||||
await page.keyboard.press("End");
|
||||
await page.keyboard.press("Enter");
|
||||
await page.keyboard.type("order.");
|
||||
await page.keyboard.type("order");
|
||||
const firstPlacement = await page.evaluateHandle(() => {
|
||||
const sample: { labelX?: number } = {};
|
||||
const observer = new MutationObserver(() => {
|
||||
const label = document.querySelector(
|
||||
":is(.cm-tooltip-above, .cm-tooltip-below).cm-lsp-completion .cm-completionLabel",
|
||||
);
|
||||
if (!label) return;
|
||||
sample.labelX = label.getBoundingClientRect().left;
|
||||
observer.disconnect();
|
||||
});
|
||||
observer.observe(document.body, { subtree: true, attributes: true, attributeFilter: ["class"] });
|
||||
return sample;
|
||||
});
|
||||
await page.keyboard.type(".");
|
||||
await page.keyboard.press("Control+Space");
|
||||
const popup = page.locator(".cm-tooltip-autocomplete");
|
||||
await expect(popup.getByText("total", { exact: true })).toBeVisible();
|
||||
@@ -83,6 +97,8 @@ test("completion lists the server's items and inserts the chosen one", async ({
|
||||
});
|
||||
const label = await method.locator(".cm-completionLabel").boundingBox();
|
||||
// Subpixel rounding differs per platform/font; a mis-set inset is a whole icon column off.
|
||||
const firstLabelX = await firstPlacement.evaluate((sample) => sample.labelX!);
|
||||
expect(Math.abs(firstLabelX - wordStart)).toBeLessThanOrEqual(2);
|
||||
expect(Math.abs(label!.x - wordStart)).toBeLessThanOrEqual(2);
|
||||
const zoomedSize = await editor.locator(".cm-content").evaluate(async (content) => {
|
||||
const viewModule = "/node_modules/.vite/deps/@codemirror_view.js";
|
||||
|
||||
@@ -2,7 +2,8 @@ import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
const amountName = "regionalSettlementAmountFromExternalProcessorBeforeRounding";
|
||||
const routingName = "settlementRoutingReferenceForCrossBorderReconciliation";
|
||||
const routingValue = "'APR-2026 / eu-west / batch-701 / settlement complete'";
|
||||
const routingText = "APR-2026 / eu-west / batch-701 / settlement complete";
|
||||
const routingValue = "'" + routingText + "'";
|
||||
|
||||
test("keeps values and their full-value action readable in a narrow debugger", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1220, height: 760 });
|
||||
@@ -46,7 +47,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(routingValue, { exact: true })).toBeVisible();
|
||||
await expect(dialog.getByText(routingText, { exact: true })).toBeVisible();
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(dialog).toBeHidden();
|
||||
|
||||
|
||||
@@ -666,12 +666,24 @@ test("dragging the Markdown split divider resizes and reflows editor and preview
|
||||
const box = (await handle.boundingBox())!;
|
||||
const startX = box.x + box.width / 2;
|
||||
const midY = box.y + box.height / 2;
|
||||
const cursorAt = (x: number) =>
|
||||
page.evaluate(({ x, y }) => getComputedStyle(document.elementFromPoint(x, y)!).cursor, { x, y: midY });
|
||||
|
||||
await page.mouse.move(startX + 40, midY);
|
||||
await page.mouse.move(startX, midY);
|
||||
expect(await cursorAt(startX)).toMatch(/resize$/);
|
||||
await page.mouse.move(startX - 5, midY);
|
||||
expect(await cursorAt(startX - 5)).not.toMatch(/resize$/);
|
||||
|
||||
await page.mouse.move(startX, midY);
|
||||
await page.mouse.down();
|
||||
await page.mouse.move(startX - 180, midY, { steps: 6 });
|
||||
await expect(handle).toHaveAttribute("data-separator", "active");
|
||||
const sourceX = (await editor.boundingBox())!.x + 60;
|
||||
expect(await cursorAt(sourceX)).toMatch(/resize$/);
|
||||
await page.mouse.up();
|
||||
await page.mouse.move(sourceX, midY);
|
||||
expect(await cursorAt(sourceX)).toBe("text");
|
||||
|
||||
await expect.poll(async () => (await editor.boundingBox())!.width).toBeLessThan(initialEditor - 150);
|
||||
await expect.poll(async () => (await preview.boundingBox())!.width).toBeGreaterThan(initialPreview + 150);
|
||||
|
||||
@@ -0,0 +1,87 @@
|
||||
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");
|
||||
});
|
||||
@@ -0,0 +1,88 @@
|
||||
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();
|
||||
});
|
||||
@@ -0,0 +1,67 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test.beforeEach(async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
await expect(page.getByRole("dialog", { name: "Settings", exact: true })).toBeVisible();
|
||||
await page.evaluate(async () => {
|
||||
const path = "/src/features/settings/model/staging.ts";
|
||||
(await import(/* @vite-ignore */ path)).selectPage("editor.fileTemplates");
|
||||
});
|
||||
});
|
||||
|
||||
test("file template fields and editors fit in narrow settings", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
const tabs = page.getByRole("tablist", { name: "Template kinds" });
|
||||
const name = page.getByRole("textbox", { name: "Template name" });
|
||||
const extension = page.getByRole("textbox", { name: "Extension" });
|
||||
const style = page.getByRole("button", { name: "File name style" });
|
||||
const body = page.getByRole("textbox", { name: "Template body", exact: true });
|
||||
|
||||
await expect(body).toBeInViewport({ ratio: 0.98 });
|
||||
expect((await body.boundingBox())!.width).toBeGreaterThan(150);
|
||||
await expect(extension).toBeInViewport({ ratio: 0.98 });
|
||||
await expect(style).toBeInViewport({ ratio: 0.98 });
|
||||
expect((await extension.boundingBox())!.y).toBeGreaterThan((await name.boundingBox())!.y);
|
||||
expect((await style.boundingBox())!.y).toBeGreaterThan((await extension.boundingBox())!.y);
|
||||
await style.click();
|
||||
await expect(page.getByRole("option", { name: "PascalCase" })).toBeVisible();
|
||||
await page.keyboard.press("Escape");
|
||||
|
||||
for (const [tab, editorName] of [
|
||||
["Includes", "Include body"],
|
||||
["Code", "Code template body"],
|
||||
]) {
|
||||
await tabs.getByRole("tab", { name: tab, exact: true }).click();
|
||||
await expect(page.getByRole("textbox", { name: editorName, exact: true })).toBeInViewport({ ratio: 0.98 });
|
||||
}
|
||||
});
|
||||
|
||||
test("file template tabs share a remembered, keyboard-adjustable divider", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 1100, height: 760 });
|
||||
const tabs = page.getByRole("tablist", { name: "Template kinds" });
|
||||
const name = page.getByRole("textbox", { name: "Template name" });
|
||||
const extension = page.getByRole("textbox", { name: "Extension" });
|
||||
const divider = page.getByRole("separator", { name: "Resize file template panes" });
|
||||
const width = async (listName: string) =>
|
||||
(await page.getByRole("listbox", { name: listName, exact: true }).boundingBox())!.width;
|
||||
|
||||
await expect(divider).toBeVisible();
|
||||
expect((await extension.boundingBox())!.y).toBe((await name.boundingBox())!.y);
|
||||
const initial = await width("File templates");
|
||||
await divider.press("ArrowRight");
|
||||
await expect.poll(() => width("File templates")).toBeGreaterThan(initial + 10);
|
||||
const resized = await width("File templates");
|
||||
|
||||
await tabs.getByRole("tab", { name: "Files", exact: true }).press("ArrowRight");
|
||||
await expect(tabs.getByRole("tab", { name: "Includes", exact: true })).toBeFocused();
|
||||
await expect.poll(() => width("Includes")).toBeCloseTo(resized, 0);
|
||||
await page.getByRole("button", { name: "Add Include" }).click();
|
||||
const include = page.getByRole("textbox", { name: "Include body" });
|
||||
await include.fill("// Shared header");
|
||||
|
||||
await tabs.getByRole("tab", { name: "Code", exact: true }).click();
|
||||
await expect.poll(() => width("Code templates")).toBeCloseTo(resized, 0);
|
||||
await tabs.getByRole("tab", { name: "Includes", exact: true }).click();
|
||||
await page.getByRole("option", { name: "New Include", exact: true }).click();
|
||||
await expect(include).toHaveValue("// Shared header");
|
||||
});
|
||||
@@ -0,0 +1,93 @@
|
||||
import { expect, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test.beforeEach(async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Inlay Hints");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
});
|
||||
|
||||
test("inlay hint categories and the preview fit at both settings widths", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const categories = dialog.getByRole("listbox", { name: "Inlay hint categories" });
|
||||
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
|
||||
await expect(preview).toBeVisible();
|
||||
await expect(preview.getByText(": f64", { exact: true })).toBeVisible();
|
||||
|
||||
await page.setViewportSize({ width: 1100, height: 760 });
|
||||
const wideList = (await categories.boundingBox())!;
|
||||
const widePreview = (await preview.boundingBox())!;
|
||||
expect(widePreview.x).toBeGreaterThan(wideList.x + wideList.width);
|
||||
expect(widePreview.y).toBeLessThan(wideList.y + wideList.height);
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
await categories.press("End");
|
||||
await expect(categories.getByRole("option", { name: /^Other hints/ })).toHaveAttribute("aria-selected", "true");
|
||||
await expect(preview.getByText("= 300", { exact: true })).toBeVisible();
|
||||
const narrowList = (await categories.boundingBox())!;
|
||||
const narrowPreview = (await preview.boundingBox())!;
|
||||
expect(narrowPreview.y).toBeGreaterThan(narrowList.y + narrowList.height);
|
||||
await expect(preview).toBeInViewport({ ratio: 0.98 });
|
||||
expect(await preview.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
});
|
||||
|
||||
test("the hint preview follows staged settings and saves the selected category", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const search = dialog.getByRole("textbox", { name: "Search settings" });
|
||||
const categories = dialog.getByRole("listbox", { name: "Inlay hint categories" });
|
||||
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
|
||||
const master = dialog.getByRole("checkbox", { name: "Show inlay hints", exact: true });
|
||||
const parameters = dialog.getByRole("checkbox", { name: "Parameter names", exact: true });
|
||||
const parameterHint = preview.getByText("width:", { exact: true });
|
||||
|
||||
await search.fill("Parameter names");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
await expect(categories.getByRole("option", { name: "Parameter names", exact: true })).toHaveAttribute(
|
||||
"aria-selected",
|
||||
"true",
|
||||
);
|
||||
await expect(parameterHint).toBeVisible();
|
||||
await master.uncheck();
|
||||
await expect(parameters).toBeDisabled();
|
||||
await expect(parameterHint).toHaveCount(0);
|
||||
await expect(dialog.getByRole("checkbox", { name: "Show Code Vision", exact: true })).toBeEnabled();
|
||||
await master.check();
|
||||
await expect(parameterHint).toBeVisible();
|
||||
|
||||
await parameters.uncheck();
|
||||
await expect(parameterHint).toHaveCount(0);
|
||||
await categories.press("Home");
|
||||
await expect(preview.getByText(": f64", { exact: true })).toBeVisible();
|
||||
await dialog.getByRole("button", { name: "Apply", exact: true }).click();
|
||||
await expect(dialog.getByRole("button", { name: "Apply", exact: true })).toBeDisabled();
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
|
||||
await page.keyboard.press("Meta+,");
|
||||
await search.fill("Parameter names");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
await expect(parameters).not.toBeChecked();
|
||||
await expect(parameterHint).toHaveCount(0);
|
||||
});
|
||||
|
||||
test("the hint preview respects the sample language's staged preference", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(() => {
|
||||
window.__ipc.handlers.languages = () => [
|
||||
{ id: "go", name: "Go" },
|
||||
{ id: "rust", name: "Rust" },
|
||||
];
|
||||
});
|
||||
await page.keyboard.press("Meta+,");
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Inlay Hints");
|
||||
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
|
||||
|
||||
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
|
||||
const typeHint = preview.getByText(": f64", { exact: true });
|
||||
await expect(typeHint).toBeVisible();
|
||||
await dialog.getByRole("checkbox", { name: "Rust", exact: true }).uncheck();
|
||||
await expect(typeHint).toHaveCount(0);
|
||||
await dialog.getByRole("listbox", { name: "Inlay hint categories" }).press("End");
|
||||
await expect(preview.getByText("= 300", { exact: true })).toBeVisible();
|
||||
});
|
||||
@@ -133,3 +133,20 @@ test("rectangular drag remains configurable after removal and saves a middle mou
|
||||
await expect(row).toContainText("Middle Click");
|
||||
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
});
|
||||
|
||||
test("the action search also finds actions by typed shortcut text", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await settings.getByRole("treeitem", { name: "Keymap", exact: true }).click();
|
||||
const search = settings.getByRole("textbox", { name: "Search actions", exact: true });
|
||||
const actions = settings.getByRole("tree", { name: "Actions" });
|
||||
const goToFile = actions.getByRole("treeitem", { name: /Go to File/ });
|
||||
for (const query of ["cmd+shift+o", "Shift+Meta+O", "⇧⌘O"]) {
|
||||
await search.fill(query);
|
||||
await expect(goToFile).toBeVisible();
|
||||
await expect(actions.getByRole("treeitem", { name: /Recent Files/ })).toHaveCount(0);
|
||||
}
|
||||
const shots = process.env.OPENIDEA_E2E_SHOTS;
|
||||
if (shots) await settings.screenshot({ path: `${shots}/after.png`, animations: "disabled" });
|
||||
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
});
|
||||
@@ -0,0 +1,73 @@
|
||||
import { expect, test } from "./fixtures";
|
||||
|
||||
test.beforeEach(async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Notifications");
|
||||
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
|
||||
});
|
||||
|
||||
test("notification group controls stay inside narrow settings", async ({ workbench: page }) => {
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
const groups = page.getByRole("region", { name: "Groups", exact: true });
|
||||
const popup = groups.getByRole("button", { name: "System Messages popup type" });
|
||||
await expect(popup).toBeInViewport({ ratio: 0.98 });
|
||||
expect(await groups.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
|
||||
|
||||
const list = groups.getByRole("listbox", { name: "Notification groups" });
|
||||
const controls = groups.getByRole("region", { name: "System Messages", exact: true });
|
||||
const listBounds = (await list.boundingBox())!;
|
||||
expect((await controls.boundingBox())!.y).toBeGreaterThanOrEqual(listBounds.y + listBounds.height);
|
||||
await popup.click();
|
||||
await expect(page.getByRole("option", { name: "Sticky balloon", exact: true })).toBeInViewport();
|
||||
await page.keyboard.press("Escape");
|
||||
|
||||
await list.press("End");
|
||||
const lastGroup = list.getByRole("option", { name: "Distraction Free Mode", exact: true });
|
||||
await expect(lastGroup).toHaveAttribute("aria-selected", "true");
|
||||
await expect(lastGroup).toBeInViewport({ ratio: 0.98 });
|
||||
await list.press("Home");
|
||||
|
||||
await page.setViewportSize({ width: 1100, height: 760 });
|
||||
const wideList = (await list.boundingBox())!;
|
||||
const wideControls = (await controls.boundingBox())!;
|
||||
expect(wideControls.x).toBeGreaterThan(wideList.x + wideList.width);
|
||||
expect(wideControls.y).toBeLessThan(wideList.y + wideList.height);
|
||||
});
|
||||
|
||||
test("notification groups follow settings search and keep edits per group", async ({ workbench: page }) => {
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
const search = dialog.getByRole("textbox", { name: "Search settings" });
|
||||
const list = dialog.getByRole("listbox", { name: "Notification groups" });
|
||||
const systemPopup = dialog.getByRole("button", { name: "System Messages popup type" });
|
||||
const versionControlPopup = dialog.getByRole("button", { name: "Version Control popup type" });
|
||||
const versionControlLog = dialog.getByRole("checkbox", { name: "Show Version Control in tool window" });
|
||||
|
||||
await list.press("ArrowDown");
|
||||
await expect(list.getByRole("option", { name: "Language Servers" })).toHaveAttribute("aria-selected", "true");
|
||||
await search.fill("Version Control");
|
||||
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
|
||||
await expect(list.getByRole("option", { name: "Version Control", exact: true })).toHaveAttribute(
|
||||
"aria-selected",
|
||||
"true",
|
||||
);
|
||||
await versionControlPopup.click();
|
||||
await page.getByRole("option", { name: "No popup", exact: true }).click();
|
||||
await versionControlLog.uncheck();
|
||||
|
||||
await list.press("Home");
|
||||
await expect(systemPopup).toHaveText("Balloon");
|
||||
await expect(dialog.getByRole("checkbox", { name: "Show System Messages in tool window" })).toBeChecked();
|
||||
await list.getByRole("option", { name: "Version Control", exact: true }).click();
|
||||
await expect(versionControlPopup).toHaveText("No popup");
|
||||
await expect(versionControlLog).not.toBeChecked();
|
||||
|
||||
await dialog.getByRole("button", { name: "Apply", exact: true }).click();
|
||||
await expect(dialog.getByRole("button", { name: "Apply", exact: true })).toBeDisabled();
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await page.keyboard.press("Meta+,");
|
||||
await search.fill("Version Control");
|
||||
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
|
||||
await expect(versionControlPopup).toHaveText("No popup");
|
||||
await expect(versionControlLog).not.toBeChecked();
|
||||
});
|
||||
@@ -0,0 +1,80 @@
|
||||
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();
|
||||
});
|
||||
@@ -82,7 +82,7 @@ test("Quick Evaluate opens an object tree that fits the editor and returns focus
|
||||
await expect(hint.getByRole("tree")).toHaveCount(0);
|
||||
await expect(hint).toHaveText(/subtotal\s*=\s*42/);
|
||||
expect(await ipcCalls(page, "debug_evaluate_in")).toEqual([
|
||||
{ session: 91, frameId: 11, expression: "summary", context: "hover" },
|
||||
{ session: 91, frameId: 11, expression: "subtotal", context: "hover" },
|
||||
{ session: 91, frameId: 11, expression: "summary", context: "watch" },
|
||||
{ session: 91, frameId: 11, expression: "subtotal", context: "watch" },
|
||||
]);
|
||||
});
|
||||
@@ -0,0 +1,103 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, ipcCalls, openFromTree, stubDesktop, test } from "./fixtures";
|
||||
|
||||
test("Safe Delete lays out the search option and makes View Usages the default in a narrow window", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
const editor = await openFromTree(page, "App.tsx");
|
||||
await page.setViewportSize({ width: 425, height: 500 });
|
||||
const content = editor.locator(".cm-content");
|
||||
const symbol = "reconcileOutstandingSupplierAdjustmentsForTheMonthlySettlementArchive";
|
||||
const source = [
|
||||
`export function ${symbol}() {`,
|
||||
" return 1;",
|
||||
"}",
|
||||
"",
|
||||
`const debit = ${symbol}();`,
|
||||
`const credit = ${symbol}();`,
|
||||
].join("\n");
|
||||
await content.evaluate(
|
||||
(element, { source, symbol }) => {
|
||||
const view = (element as HTMLElement & { cmTile: { view: EditorView } }).cmTile.view;
|
||||
view.dispatch({
|
||||
changes: { from: 0, to: view.state.doc.length, insert: source },
|
||||
selection: { anchor: source.indexOf(symbol) + 1 },
|
||||
});
|
||||
view.focus();
|
||||
},
|
||||
{ source, symbol },
|
||||
);
|
||||
await stubDesktop(page);
|
||||
await page.evaluate(
|
||||
({ source, symbol }) => {
|
||||
const path = "/dev/acme-api/App.tsx";
|
||||
const range = (line: number, col: number, end = col + symbol.length) => ({
|
||||
start: { line, col },
|
||||
end: { line, col: end },
|
||||
});
|
||||
const selection = range(0, "export function ".length);
|
||||
const handlers = window.__ipc.handlers;
|
||||
handlers.lsp_goto = () => [{ path, range: selection }];
|
||||
handlers.doc_outline = () => [
|
||||
{
|
||||
name: symbol,
|
||||
detail: null,
|
||||
kind: "function",
|
||||
range: { start: { line: 0, col: 0 }, end: { line: 2, col: 1 } },
|
||||
selection_range: selection,
|
||||
children: [],
|
||||
},
|
||||
];
|
||||
handlers.languages = () => [];
|
||||
handlers.lsp_references = () => ({
|
||||
locations: [
|
||||
{ path, range: range(4, "const debit = ".length) },
|
||||
{ path, range: range(5, "const credit = ".length) },
|
||||
],
|
||||
incomplete: null,
|
||||
});
|
||||
handlers.fs_read_text = () => source;
|
||||
},
|
||||
{ source, symbol },
|
||||
);
|
||||
const openSafeDelete = () =>
|
||||
page.evaluate(async () => {
|
||||
const module = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ module);
|
||||
void executeAction("refactor.safeDelete");
|
||||
});
|
||||
const usageSearches = async () => (await ipcCalls(page, "lsp_references")).filter((call) => call.projectWide);
|
||||
|
||||
await openSafeDelete();
|
||||
const prompt = page.getByRole("dialog", { name: "Safe Delete", exact: true });
|
||||
await expect(prompt.locator("[data-dialog-titlebar]")).toHaveText("Safe Delete");
|
||||
const description = prompt.getByText(`Delete Function '${symbol}'?`);
|
||||
const commentSearch = prompt.getByRole("checkbox", { name: "Search in comments and strings" });
|
||||
await expect(commentSearch).toBeChecked();
|
||||
const expectedLeft = (await description.boundingBox())!.x;
|
||||
expect((await commentSearch.boundingBox())!.x).toBeCloseTo(expectedLeft, 0);
|
||||
await expect(prompt.locator("[data-dialog-body]")).toContainText(symbol);
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(prompt).toBeHidden();
|
||||
await expect(content).toBeFocused();
|
||||
expect(await usageSearches()).toHaveLength(0);
|
||||
|
||||
await openSafeDelete();
|
||||
await commentSearch.uncheck();
|
||||
await prompt.getByRole("button", { name: "OK", exact: true }).click();
|
||||
const conflict = page.getByRole("dialog", { name: "Usages Detected", exact: true });
|
||||
await expect(conflict.getByRole("heading", { name: "2 usages found" })).toBeVisible();
|
||||
await expect(conflict.getByText(`Function '${symbol}' has 2 usages that are not safe to delete.`)).toBeVisible();
|
||||
for (const button of ["View Usages", "Delete Anyway", "Cancel"]) {
|
||||
await expect(conflict.getByRole("button", { name: button, exact: true })).toBeInViewport({ ratio: 1 });
|
||||
}
|
||||
expect(
|
||||
await conflict.locator("[data-dialog-body]").evaluate((element) => element.scrollWidth - element.clientWidth),
|
||||
).toBe(0);
|
||||
await expect(conflict.getByRole("button", { name: "View Usages" })).toBeFocused();
|
||||
await page.keyboard.press("Enter");
|
||||
await expect(conflict).toBeHidden();
|
||||
await expect(page.getByRole("region", { name: "Find Usages", exact: true })).toBeVisible();
|
||||
await expect(content).toContainText("export function");
|
||||
expect(await usageSearches()).toHaveLength(1);
|
||||
});
|
||||
@@ -184,6 +184,7 @@ 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 });
|
||||
@@ -201,16 +202,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(dialog.getByLabel("Font preview")).toHaveCSS("font-family", /^Inter, "Inter Variable",/);
|
||||
await expect(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(dialog.getByLabel("Font preview")).toHaveCSS("font-family", /Maple Mono NF.*Inter Variable/);
|
||||
await expect(preview).toHaveCSS("font-family", /Maple Mono NF.*Inter Variable/);
|
||||
await fallback.fill("思源宋体");
|
||||
await fallback.press("Enter");
|
||||
await expect(dialog.getByLabel("Font preview")).toHaveCSS("font-family", /思源宋体/);
|
||||
await expect(preview).toHaveCSS("font-family", /思源宋体/);
|
||||
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
|
||||
await expect(dialog).toBeHidden();
|
||||
});
|
||||
@@ -69,20 +69,53 @@ test("every color scheme page keeps its attribute tree visible", async ({ workbe
|
||||
}
|
||||
});
|
||||
|
||||
for (const id of ["editor.fileTemplates", "editor.liveTemplates"]) {
|
||||
test(`${id} keeps its editor reachable beside the template list`, async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
await expect(page.getByRole("dialog", { name: "Settings", exact: true })).toBeVisible();
|
||||
await page.evaluate(async (id) => {
|
||||
const path = "/src/features/settings/model/staging.ts";
|
||||
(await import(/* @vite-ignore */ path)).selectPage(id);
|
||||
}, id);
|
||||
await page.setViewportSize({ width: 520, height: 760 });
|
||||
const editor = page.locator("[class*='split'] > [class*='editor']").first();
|
||||
await expect(editor).toBeAttached();
|
||||
expect((await editor.boundingBox())!.width).toBeGreaterThan(200);
|
||||
test("Live Templates gives the editor the full settings pane width and keeps variable fields reachable", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.keyboard.press("Meta+,");
|
||||
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
|
||||
await expect(dialog).toBeVisible();
|
||||
await page.evaluate(async () => {
|
||||
const path = "/src/features/settings/model/staging.ts";
|
||||
(await import(/* @vite-ignore */ path)).selectPage("editor.liveTemplates");
|
||||
});
|
||||
}
|
||||
const list = dialog.getByRole("listbox", { name: "Live templates" });
|
||||
const body = dialog.getByRole("textbox", { name: "Template text" });
|
||||
await dialog.getByRole("button", { name: "Add Template" }).click();
|
||||
await expect(body).toBeVisible();
|
||||
const listBounds = (await list.boundingBox())!;
|
||||
const bodyBounds = (await body.boundingBox())!;
|
||||
expect(bodyBounds.y).toBeGreaterThan(listBounds.y + listBounds.height);
|
||||
expect(bodyBounds.width).toBeGreaterThan(listBounds.width - 32);
|
||||
|
||||
const handle = dialog.getByRole("separator", { name: "Resize template panes" });
|
||||
await expect(handle).toHaveAttribute("aria-orientation", "horizontal");
|
||||
await handle.press("ArrowDown");
|
||||
await expect.poll(async () => (await list.boundingBox())!.height).toBeGreaterThan(listBounds.height + 10);
|
||||
|
||||
await dialog.getByRole("textbox", { name: "Abbreviation" }).fill("settlement");
|
||||
await dialog.getByRole("textbox", { name: "Filter templates" }).fill("settlement");
|
||||
await expect(list.getByRole("option")).toHaveCount(1);
|
||||
await expect(list.getByRole("option")).toHaveAttribute("aria-selected", "true");
|
||||
await body.fill("record($SETTLEMENT_REFERENCE_IDENTIFIER$, $AMOUNT$)$END$");
|
||||
|
||||
await page.setViewportSize({ width: 520, height: 600 });
|
||||
await body.scrollIntoViewIfNeeded();
|
||||
await expect(body).toBeInViewport({ ratio: 0.98 });
|
||||
const narrowList = (await list.boundingBox())!;
|
||||
const narrowBody = (await body.boundingBox())!;
|
||||
expect(narrowBody.x + narrowBody.width).toBeLessThanOrEqual(narrowList.x + narrowList.width);
|
||||
const variables = dialog.getByRole("table");
|
||||
const expression = variables.getByRole("textbox", { name: "SETTLEMENT_REFERENCE_IDENTIFIER expression" });
|
||||
await expression.scrollIntoViewIfNeeded();
|
||||
await expect(expression).toBeInViewport({ ratio: 1 });
|
||||
await expression.fill("fileName()");
|
||||
await expect(expression).toHaveValue("fileName()");
|
||||
await expect(
|
||||
variables.getByRole("checkbox", { name: "Skip SETTLEMENT_REFERENCE_IDENTIFIER if defined" }),
|
||||
).toBeVisible();
|
||||
expect(await variables.evaluate((element) => element.scrollWidth - element.clientWidth)).toBe(0);
|
||||
});
|
||||
|
||||
test("Project Structure keeps every details pane usable in a compact window", async ({ workbench: page }) => {
|
||||
await page.keyboard.press("Meta+;");
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
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");
|
||||
});
|
||||
@@ -0,0 +1,74 @@
|
||||
import type { EditorView } from "@codemirror/view";
|
||||
import { expect, openFromTree, test } from "./fixtures";
|
||||
|
||||
test("Surround With keeps its title and keyboard-selected actions visible in a short window", async ({
|
||||
workbench: page,
|
||||
}) => {
|
||||
await page.setViewportSize({ width: 680, height: 320 });
|
||||
const editor = await openFromTree(page, "App.tsx");
|
||||
const content = editor.locator(".cm-content");
|
||||
const source = [
|
||||
"const fee = 5;",
|
||||
"",
|
||||
"function settle(amount: number) {",
|
||||
" const adjusted = amount - fee;",
|
||||
" const receipt = adjusted.toString();",
|
||||
" console.log(receipt);",
|
||||
" return adjusted;",
|
||||
"}",
|
||||
].join("\n");
|
||||
const selectedText = " console.log(receipt);";
|
||||
await content.evaluate(
|
||||
(node, { source, selectedText }) => {
|
||||
const view = (node as HTMLElement & { cmTile: { view: EditorView } }).cmTile.view;
|
||||
const start = source.indexOf(selectedText);
|
||||
view.dispatch({
|
||||
changes: { from: 0, to: view.state.doc.length, insert: source },
|
||||
selection: { anchor: start, head: start + selectedText.length },
|
||||
scrollIntoView: true,
|
||||
});
|
||||
view.focus();
|
||||
},
|
||||
{ source, selectedText },
|
||||
);
|
||||
const openSurround = () =>
|
||||
page.evaluate(async () => {
|
||||
const module = "/src/platform/actions.ts";
|
||||
const { executeAction } = await import(/* @vite-ignore */ module);
|
||||
await executeAction("code.surroundWith");
|
||||
});
|
||||
|
||||
await openSurround();
|
||||
const popup = page.getByRole("dialog", { name: "Surround With", exact: true });
|
||||
const title = popup.getByText("Surround With", { exact: true });
|
||||
const list = popup.getByRole("listbox");
|
||||
await expect(title).toBeInViewport({ ratio: 1 });
|
||||
await expect.poll(() => list.evaluate((node) => node.scrollHeight - node.clientHeight)).toBeGreaterThan(0);
|
||||
await expect.poll(() => popup.evaluate((node) => node.scrollHeight - node.clientHeight)).toBe(0);
|
||||
|
||||
const first = list.getByRole("option", { name: /^1\.?\s+if$/ });
|
||||
await expect(first).toHaveAttribute("aria-selected", "true");
|
||||
const action = first.getByText("if", { exact: true });
|
||||
const mnemonic = first.getByText(/^1\.?$/, { exact: true });
|
||||
expect((await mnemonic.boundingBox())!.x + (await mnemonic.boundingBox())!.width).toBeLessThan(
|
||||
(await action.boundingBox())!.x,
|
||||
);
|
||||
expect(await action.evaluate((node) => getComputedStyle(node).fontSize)).toBe("13px");
|
||||
await page.keyboard.press("End");
|
||||
const last = list.getByRole("option", { name: /!\(expr\)/ });
|
||||
await expect(last).toHaveAttribute("aria-selected", "true");
|
||||
await expect(last).toBeInViewport({ ratio: 1 });
|
||||
await expect(title).toBeInViewport({ ratio: 1 });
|
||||
|
||||
await page.keyboard.press("Escape");
|
||||
await expect(popup).toBeHidden();
|
||||
await expect(content).toBeFocused();
|
||||
await expect(content).toContainText("console.log(receipt);");
|
||||
|
||||
await openSurround();
|
||||
await expect(first).toBeVisible();
|
||||
await page.keyboard.press("1");
|
||||
await expect(popup).toBeHidden();
|
||||
await expect(content).toContainText(/if \([^)]*\) \{/);
|
||||
await expect(content).toContainText("console.log(receipt);");
|
||||
});
|
||||
@@ -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.0
|
||||
Bundle-Version: 1.1.1
|
||||
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,6 +123,13 @@ 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
|
||||
@@ -204,7 +211,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
|
||||
|
||||
```
|
||||
22980a16bd8e303d67ed2e04d76d8974f2d3981120c26e6d9afa47ba361b1503 openidea-jvm-inspect.jar
|
||||
4ab30723afe1254b991d9457ea66271109f397a17b238870572283aad73338ad openidea-jvm-inspect.jar
|
||||
```
|
||||
|
||||
Change `Bundle-Version` whenever the jar changes: OSGi caches bundles by version.
|
||||
|
||||
Бінарний файл не відображається.
@@ -31,6 +31,8 @@ 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;
|
||||
@@ -170,6 +172,10 @@ 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;
|
||||
@@ -514,6 +520,8 @@ 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;
|
||||
@@ -532,10 +540,61 @@ 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
|
||||
@@ -758,9 +817,11 @@ final class RealRunTrace {
|
||||
/** Worker: everything the trace holds, a parked thread the client never stepped out included. */
|
||||
private void dispose() {
|
||||
if (parked != null) {
|
||||
if (stillParked()) resume(parked);
|
||||
// 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);
|
||||
parked = null;
|
||||
}
|
||||
deleteUncaught();
|
||||
teardown();
|
||||
for (ObjectReference o : pinned) {
|
||||
try {
|
||||
@@ -996,6 +1057,8 @@ 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,6 +100,9 @@ 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;
|
||||
@@ -244,6 +247,23 @@ 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);
|
||||
@@ -1025,6 +1045,77 @@ 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" }
|
||||
initialization-options = { semanticTokens = true, vulncheck = "Imports", hints = { constantValues = true } }
|
||||
root-markers = ["go.work", "go.mod"]
|
||||
install-hint = "go install golang.org/x/tools/gopls@latest"
|
||||
|
||||
|
||||
@@ -26,6 +26,8 @@ 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"
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
diff --git a/dist/index.cjs b/dist/index.cjs
|
||||
index 4172cb0f2befc00da9ae09eb3486cae743403a97..ed3c542377fc6dff0195dd9116c16464fb615919 100644
|
||||
--- a/dist/index.cjs
|
||||
+++ b/dist/index.cjs
|
||||
@@ -208,7 +208,9 @@ class Stack {
|
||||
if (index > 0 && (this.buffer[index - 4] != 0 /* Term.Err */ || this.buffer[index - 1] < 0)) {
|
||||
let mustMove = false;
|
||||
for (let scan = index; scan > 0 && this.buffer[scan - 2] > end; scan -= 4) {
|
||||
- if (this.buffer[scan - 1] >= 0) {
|
||||
+ // Reused skipped nodes after the end must be moved out too.
|
||||
+ if (this.buffer[scan - 1] >= 0 ||
|
||||
+ this.buffer[scan - 1] == -1 && this.p.reused[this.buffer[scan - 4]].type.isSkipped) {
|
||||
mustMove = true;
|
||||
break;
|
||||
}
|
||||
@@ -278,7 +280,11 @@ class Stack {
|
||||
this.p.reused.push(value);
|
||||
index++;
|
||||
}
|
||||
- let end = this.reducePos = this.pos = start + value.length;
|
||||
+ // A reused skipped node (a comment) is not part of the node being
|
||||
+ // reduced: like a shifted skipped token, it leaves reducePos alone.
|
||||
+ let end = this.pos = start + value.length;
|
||||
+ if (!value.type.isSkipped)
|
||||
+ this.reducePos = end;
|
||||
this.pushState(next, start);
|
||||
this.buffer.push(index, start, end, -1 /* size == -1 means this is a reused value */);
|
||||
if (this.curContext)
|
||||
diff --git a/dist/index.js b/dist/index.js
|
||||
index 8fd3f87829c312b93ce022867fd17bf34da0dbc0..f67b16d2f46d683f12ddc81534efbf50925e7c65 100644
|
||||
--- a/dist/index.js
|
||||
+++ b/dist/index.js
|
||||
@@ -206,7 +206,9 @@ class Stack {
|
||||
if (index > 0 && (this.buffer[index - 4] != 0 /* Term.Err */ || this.buffer[index - 1] < 0)) {
|
||||
let mustMove = false;
|
||||
for (let scan = index; scan > 0 && this.buffer[scan - 2] > end; scan -= 4) {
|
||||
- if (this.buffer[scan - 1] >= 0) {
|
||||
+ // Reused skipped nodes after the end must be moved out too.
|
||||
+ if (this.buffer[scan - 1] >= 0 ||
|
||||
+ this.buffer[scan - 1] == -1 && this.p.reused[this.buffer[scan - 4]].type.isSkipped) {
|
||||
mustMove = true;
|
||||
break;
|
||||
}
|
||||
@@ -276,7 +278,11 @@ class Stack {
|
||||
this.p.reused.push(value);
|
||||
index++;
|
||||
}
|
||||
- let end = this.reducePos = this.pos = start + value.length;
|
||||
+ // A reused skipped node (a comment) is not part of the node being
|
||||
+ // reduced: like a shifted skipped token, it leaves reducePos alone.
|
||||
+ let end = this.pos = start + value.length;
|
||||
+ if (!value.type.isSkipped)
|
||||
+ this.reducePos = end;
|
||||
this.pushState(next, start);
|
||||
this.buffer.push(index, start, end, -1 /* size == -1 means this is a reused value */);
|
||||
if (this.curContext)
|
||||
Створено
+27
-26
@@ -9,6 +9,7 @@ overrides:
|
||||
|
||||
patchedDependencies:
|
||||
'@codemirror/view': 0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5
|
||||
'@lezer/lr': 1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8
|
||||
|
||||
importers:
|
||||
|
||||
@@ -82,7 +83,7 @@ importers:
|
||||
version: 1.2.5
|
||||
'@lezer/lr':
|
||||
specifier: ^1.4.11
|
||||
version: 1.4.11
|
||||
version: 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@plutojl/lang-julia':
|
||||
specifier: ^1.2.0
|
||||
version: 1.2.0
|
||||
@@ -2408,7 +2409,7 @@ snapshots:
|
||||
'@codemirror/language': 6.13.1
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2467,7 +2468,7 @@ snapshots:
|
||||
'@codemirror/view': 6.43.14(patch_hash=0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5)
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2480,7 +2481,7 @@ snapshots:
|
||||
'@codemirror/language': 6.13.1
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2491,7 +2492,7 @@ snapshots:
|
||||
'@codemirror/view': 6.43.14(patch_hash=0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5)
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2539,7 +2540,7 @@ snapshots:
|
||||
'@codemirror/state': 6.7.6
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2548,14 +2549,14 @@ snapshots:
|
||||
'@codemirror/language': 6.13.1
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
'@codemirror/language': 6.13.1
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
dependencies:
|
||||
@@ -2573,7 +2574,7 @@ snapshots:
|
||||
'@codemirror/state': 6.7.6
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
'@lezer/yaml': 1.0.4
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
@@ -2609,7 +2610,7 @@ snapshots:
|
||||
'@codemirror/view': 6.43.14(patch_hash=0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5)
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
style-mod: 4.1.4
|
||||
|
||||
'@codemirror/[email protected]':
|
||||
@@ -2745,24 +2746,24 @@ snapshots:
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
@@ -2772,27 +2773,27 @@ snapshots:
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
'@lezer/[email protected](patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
|
||||
@@ -2805,37 +2806,37 @@ snapshots:
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@lezer/[email protected]':
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@marijn/[email protected]': {}
|
||||
|
||||
@@ -3101,7 +3102,7 @@ snapshots:
|
||||
dependencies:
|
||||
'@lezer/common': 1.5.3
|
||||
'@lezer/highlight': 1.2.5
|
||||
'@lezer/lr': 1.4.11
|
||||
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
|
||||
|
||||
'@replit/[email protected]': {}
|
||||
|
||||
|
||||
@@ -5,3 +5,4 @@ overrides:
|
||||
mermaid>katex: ^0.18.2
|
||||
patchedDependencies:
|
||||
"@codemirror/view": patches/@codemirror__view.patch
|
||||
"@lezer/lr": patches/@lezer__lr.patch
|
||||
@@ -41,6 +41,7 @@ ide-core.workspace = true
|
||||
ide-cli.workspace = true
|
||||
dunce.workspace = true
|
||||
ide-clipboard.workspace = true
|
||||
ide-drag-out.workspace = true
|
||||
ide-fonts.workspace = true
|
||||
ide-text.workspace = true
|
||||
ide-vfs.workspace = true
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
//! Native window drag started from the web title bar.
|
||||
//! Native drags started from the web UI: the window from its title bar, files out to other apps.
|
||||
|
||||
use ide_command::desktop_command;
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use std::path::PathBuf;
|
||||
use tauri::WebviewWindow;
|
||||
|
||||
/// Starts dragging `window` while the primary mouse button is still down; returns whether a drag began.
|
||||
@@ -20,4 +21,41 @@ pub fn window_start_drag(window: WebviewWindow) -> IdeResult<bool> {
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
ide_command::desktop_domain!(window_start_drag);
|
||||
/// Drags `paths` (local files and folders) out of `window` while the primary mouse button is
|
||||
/// still down, so the app they are dropped on copies them (#2867). Resolves when the drag ends,
|
||||
/// with whether a target took the files.
|
||||
#[desktop_command(trust = always)]
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub async fn window_drag_files(window: WebviewWindow, paths: Vec<PathBuf>) -> IdeResult<bool> {
|
||||
let paths = ide_drag_out::local_paths(paths)?;
|
||||
let (started_tx, started_rx) = tokio::sync::oneshot::channel();
|
||||
let (done_tx, done_rx) = tokio::sync::oneshot::channel();
|
||||
let source = window.clone();
|
||||
window
|
||||
.run_on_main_thread(move || {
|
||||
let done = move |outcome| {
|
||||
let _ = done_tx.send(outcome);
|
||||
};
|
||||
// A tap WebKit delivered late: nothing is held, so the drag would never end.
|
||||
#[cfg(target_os = "macos")]
|
||||
if objc2_app_kit::NSEvent::pressedMouseButtons() & 1 == 0 {
|
||||
let _ = started_tx.send(Ok(()));
|
||||
return;
|
||||
}
|
||||
#[cfg(target_os = "linux")]
|
||||
let started = source
|
||||
.gtk_window()
|
||||
.map_err(|error| std::io::Error::other(error.to_string()))
|
||||
.and_then(|gtk_window| ide_drag_out::start(>k_window, paths, done));
|
||||
#[cfg(any(windows, target_os = "macos"))]
|
||||
let started = ide_drag_out::start(&source, paths, done);
|
||||
let _ = started_tx.send(started);
|
||||
})
|
||||
.map_err(|error| IdeError::internal(format!("Cannot start a drag on the main thread: {error}")))?;
|
||||
started_rx.await.map_err(|error| IdeError::internal(error.to_string()))??;
|
||||
// Dropped without an outcome when the drag never began or its backend lost it.
|
||||
Ok(matches!(done_rx.await, Ok(ide_drag_out::Outcome::Dropped)))
|
||||
}
|
||||
|
||||
ide_command::desktop_domain!(window_start_drag, window_drag_files);
|
||||
@@ -4,9 +4,15 @@
|
||||
//! renderer, so that is done before the first web view is created. Turning the DMA-BUF
|
||||
//! renderer off also avoids it, but then WebKit paints on the CPU and a tool window drag
|
||||
//! stalls the UI for seconds; setting `WEBKIT_DISABLE_DMABUF_RENDERER=1` still does that.
|
||||
//!
|
||||
//! On Wayland, GTK's default input method goes through the compositor (text-input-v3).
|
||||
//! With IBus behind it, a dead key waiting for its second key makes WebKit collapse every
|
||||
//! new selection in the window to its caret (Select All, mouse drags, text fields) until a
|
||||
//! composition completes. GTK's own IBus module does not, so IBus sessions use that.
|
||||
|
||||
const DISABLE_DMABUF: &str = "WEBKIT_DISABLE_DMABUF_RENDERER";
|
||||
const DISABLE_EXPLICIT_SYNC: &str = "__NV_DISABLE_EXPLICIT_SYNC";
|
||||
const IM_MODULE: &str = "GTK_IM_MODULE";
|
||||
|
||||
/// Run before other threads start (`set_var`).
|
||||
#[cfg(target_os = "linux")]
|
||||
@@ -16,6 +22,35 @@ pub fn configure() {
|
||||
tracing::info!("Wayland with the NVIDIA driver: {DISABLE_EXPLICIT_SYNC}=1");
|
||||
unsafe { std::env::set_var(DISABLE_EXPLICIT_SYNC, "1") };
|
||||
}
|
||||
if use_ibus_module(|k| std::env::var(k).ok(), gtk_ibus_module_installed) {
|
||||
tracing::info!("Wayland with IBus: {IM_MODULE}=ibus");
|
||||
unsafe { std::env::set_var(IM_MODULE, "ibus") };
|
||||
}
|
||||
}
|
||||
|
||||
/// GTK 3's IBus input method module (`ibus-gtk3`), wherever the distribution keeps it.
|
||||
#[cfg(target_os = "linux")]
|
||||
fn gtk_ibus_module_installed() -> bool {
|
||||
const MODULE: &str = "gtk-3.0/3.0.0/immodules/im-ibus.so";
|
||||
let lib_dirs = ["/usr/lib", "/usr/lib64", "/usr/local/lib"];
|
||||
lib_dirs.iter().any(|dir| {
|
||||
let dir = std::path::Path::new(dir);
|
||||
dir.join(MODULE).exists()
|
||||
|| std::fs::read_dir(dir)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.flatten()
|
||||
.any(|multiarch| multiarch.path().join(MODULE).exists())
|
||||
})
|
||||
}
|
||||
|
||||
/// A Wayland session whose input method is IBus, unless the user chose a GTK module.
|
||||
fn use_ibus_module(var: impl Fn(&str) -> Option<String>, module_installed: impl FnOnce() -> bool) -> bool {
|
||||
if var(IM_MODULE).is_some_and(|v| !v.is_empty()) || !gdk_wayland(&var) {
|
||||
return false;
|
||||
}
|
||||
let ibus = var("XMODIFIERS").is_some_and(|v| v.split_whitespace().any(|m| m == "@im=ibus"));
|
||||
ibus && module_installed()
|
||||
}
|
||||
|
||||
/// Applies Appearance › Smooth scrolling to every new web view
|
||||
@@ -46,11 +81,15 @@ fn disable_explicit_sync(var: impl Fn(&str) -> Option<String>, nvidia: bool) ->
|
||||
if !nvidia || var(DISABLE_DMABUF).is_some() || var(DISABLE_EXPLICIT_SYNC).is_some() {
|
||||
return false;
|
||||
}
|
||||
gdk_wayland(&var)
|
||||
}
|
||||
|
||||
/// GDK will open a Wayland display (it tries the backends of `GDK_BACKEND` in order).
|
||||
fn gdk_wayland(var: &impl Fn(&str) -> Option<String>) -> bool {
|
||||
let wayland_display = var("WAYLAND_DISPLAY").is_some_and(|v| !v.is_empty());
|
||||
// GDK tries the backends of `GDK_BACKEND` in order.
|
||||
let gdk_wayland =
|
||||
let backend =
|
||||
var("GDK_BACKEND").is_none_or(|b| matches!(b.split(',').next().map(str::trim), Some("wayland" | "*" | "")));
|
||||
wayland_display && gdk_wayland
|
||||
wayland_display && backend
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -76,4 +115,26 @@ mod tests {
|
||||
assert!(!decide(&[("WAYLAND_DISPLAY", "wayland-0"), (DISABLE_DMABUF, "1")], true));
|
||||
assert!(!decide(&[("WAYLAND_DISPLAY", "wayland-0"), (DISABLE_EXPLICIT_SYNC, "0")], true));
|
||||
}
|
||||
|
||||
fn decide_im(vars: &[(&str, &str)], installed: bool) -> bool {
|
||||
use_ibus_module(|k| vars.iter().find(|(name, _)| *name == k).map(|(_, v)| v.to_string()), || installed)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn uses_the_ibus_module_on_wayland_with_ibus_only() {
|
||||
let gnome = [("WAYLAND_DISPLAY", "wayland-0"), ("XMODIFIERS", "@im=ibus")];
|
||||
assert!(decide_im(&gnome, true));
|
||||
assert!(decide_im(&[gnome[0], gnome[1], (IM_MODULE, "")], true));
|
||||
assert!(!decide_im(&gnome, false));
|
||||
assert!(!decide_im(&[("WAYLAND_DISPLAY", "wayland-0"), ("XMODIFIERS", "@im=fcitx")], true));
|
||||
assert!(!decide_im(&[("WAYLAND_DISPLAY", "wayland-0")], true));
|
||||
assert!(!decide_im(&[("DISPLAY", ":0"), ("XMODIFIERS", "@im=ibus")], true));
|
||||
assert!(!decide_im(&[gnome[0], gnome[1], ("GDK_BACKEND", "x11")], true));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn keeps_the_users_input_method_module() {
|
||||
let vars = [("WAYLAND_DISPLAY", "wayland-0"), ("XMODIFIERS", "@im=ibus"), (IM_MODULE, "wayland")];
|
||||
assert!(!decide_im(&vars, true));
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,8 @@ agent_archive always project_host bin
|
||||
agent_base_text trusted project_host bindings async
|
||||
agent_cancel always project_host bindings sync
|
||||
agent_changes trusted project_host bindings async
|
||||
agent_cli_update trusted project_host bindings async
|
||||
agent_cli_update_check trusted project_host bindings async
|
||||
agent_commands always project_host bindings async
|
||||
agent_context_usage trusted project_host bindings async
|
||||
agent_create trusted project_host bindings async
|
||||
@@ -171,6 +173,7 @@ debug_jvm_memory_referrers trusted project_host bin
|
||||
debug_listen_for_jvm trusted project_host bindings async
|
||||
debug_pause trusted project_host bindings async
|
||||
debug_redefine_classes trusted project_host bindings async
|
||||
debug_resolve_variable trusted project_host bindings async
|
||||
debug_restart_frame trusted project_host bindings async
|
||||
debug_resume trusted project_host bindings async
|
||||
debug_run_to trusted project_host bindings async
|
||||
@@ -728,6 +731,7 @@ web_url always project_host bin
|
||||
window_close_context always desktop bindings sync
|
||||
window_complete_launch always desktop bindings sync
|
||||
window_cycle always desktop bindings sync
|
||||
window_drag_files always desktop bindings async
|
||||
window_flash_taskbar always desktop bindings sync
|
||||
window_group_cancel_close always desktop bindings sync
|
||||
window_group_close always desktop bindings sync
|
||||
|
||||
+60
-5
@@ -33,6 +33,10 @@ export const commands = {
|
||||
"group" |
|
||||
/** What the last turn changed, against the checkout as that turn started. */
|
||||
"lastTurn" | null) => typedError<AgentChange[], IdeError>(__TAURI_INVOKE("agent_changes", { task, view })),
|
||||
/** Installs the exact version offered if the selected installation still matches. */
|
||||
agentCliUpdate: (provider: string, offer: AgentCliOffer, request: RequestId) => typedError<AgentCliUpdateResult, IdeError>(__TAURI_INVOKE("agent_cli_update", { provider, offer, request })),
|
||||
/** Checks the selected installation without modifying it. */
|
||||
agentCliUpdateCheck: (provider: string, request: RequestId) => typedError<AgentCliUpdateResult, IdeError>(__TAURI_INVOKE("agent_cli_update_check", { provider, request })),
|
||||
/**
|
||||
* Slash commands to complete for `provider` in `task`'s directory, or in the project
|
||||
* before a task exists (skills and custom commands on disk included).
|
||||
@@ -369,9 +373,9 @@ export const commands = {
|
||||
/** Completions for an expression typed in Evaluate (`line` / `column` 0-based, UTF-16). */
|
||||
debugCompletions: (session: DebugSessionId, frameId: number | null, text: string, line: number, column: number) => typedError<DebugCompletion[], IdeError>(__TAURI_INVOKE("debug_completions", { session, frameId, text, line, column })),
|
||||
debugDataBreakpointInfo: (session: DebugSessionId, container: number, name: string, frameId: number | null) => typedError<DataBreakpointInfo, IdeError>(__TAURI_INVOKE("debug_data_breakpoint_info", { session, container, name, frameId })),
|
||||
debugEvaluate: (session: DebugSessionId, frameId: number | null, expression: string) => typedError<Variable, IdeError>(__TAURI_INVOKE("debug_evaluate", { session, frameId, expression })),
|
||||
debugEvaluate: (session: DebugSessionId, frameId: number | null, expression: string) => typedError<Variable_Serialize, IdeError>(__TAURI_INVOKE("debug_evaluate", { session, frameId, expression })),
|
||||
/** Evaluate with an explicit DAP context: `repl`, `watch`, `hover` or `clipboard`. */
|
||||
debugEvaluateIn: (session: DebugSessionId, frameId: number | null, expression: string, context: string | null) => typedError<Variable, IdeError>(__TAURI_INVOKE("debug_evaluate_in", { session, frameId, expression, context })),
|
||||
debugEvaluateIn: (session: DebugSessionId, frameId: number | null, expression: string, context: string | null) => typedError<Variable_Serialize, IdeError>(__TAURI_INVOKE("debug_evaluate_in", { session, frameId, expression, context })),
|
||||
debugExceptionFilters: () => typedError<SessionExceptionFilters[], IdeError>(__TAURI_INVOKE("debug_exception_filters")),
|
||||
/** Force Step Over: step over with every breakpoint suspended until the step ends. */
|
||||
debugForceStepOver: (session: DebugSessionId, threadId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_force_step_over", { session, threadId })),
|
||||
@@ -426,6 +430,7 @@ export const commands = {
|
||||
debugPause: (session: DebugSessionId, threadId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_pause", { session, threadId })),
|
||||
/** HotSwap (Reload Changed Classes) in a java-debug session. */
|
||||
debugRedefineClasses: (session: DebugSessionId) => typedError<HotSwapResult, IdeError>(__TAURI_INVOKE("debug_redefine_classes", { session })),
|
||||
debugResolveVariable: (session: DebugSessionId, variable: Variable_Deserialize) => typedError<Variable_Serialize, IdeError>(__TAURI_INVOKE("debug_resolve_variable", { session, variable })),
|
||||
/** Reset Frame (Drop Frame). */
|
||||
debugRestartFrame: (session: DebugSessionId, frameId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_restart_frame", { session, frameId })),
|
||||
debugResume: (session: DebugSessionId, threadId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_resume", { session, threadId })),
|
||||
@@ -441,7 +446,7 @@ export const commands = {
|
||||
debugSetExceptionBreakpoints: (choices: { [key in string]: boolean }) => typedError<null, IdeError>(__TAURI_INVOKE("debug_set_exception_breakpoints", { choices })),
|
||||
/** Method breakpoints (all files); states aligned with `breakpoints`. */
|
||||
debugSetFunctionBreakpoints: (breakpoints: FunctionBreakpoint[]) => typedError<BreakpointState[], IdeError>(__TAURI_INVOKE("debug_set_function_breakpoints", { breakpoints })),
|
||||
debugSetVariable: (session: DebugSessionId, container: number, name: string, evaluateName: string | null, frameId: number | null, value: string) => typedError<Variable, IdeError>(__TAURI_INVOKE("debug_set_variable", { session, container, name, evaluateName, frameId, value })),
|
||||
debugSetVariable: (session: DebugSessionId, container: number, name: string, evaluateName: string | null, frameId: number | null, value: string) => typedError<Variable_Serialize, IdeError>(__TAURI_INVOKE("debug_set_variable", { session, container, name, evaluateName, frameId, value })),
|
||||
debugStackTrace: (session: DebugSessionId, threadId: number) => typedError<StackFrame[], IdeError>(__TAURI_INVOKE("debug_stack_trace", { session, threadId })),
|
||||
/** Starts a session owned by this window: its events (and those of child sessions) go here only. */
|
||||
debugStart: (config: LaunchConfig) => typedError<DebugSessionId, IdeError>(__TAURI_INVOKE("debug_start", { config })),
|
||||
@@ -467,7 +472,7 @@ export const commands = {
|
||||
{ kind: "finished" } | null, IdeError>(__TAURI_INVOKE("debug_stream_trace_abort", { session })),
|
||||
debugThreads: (session: DebugSessionId) => typedError<ThreadInfo[], IdeError>(__TAURI_INVOKE("debug_threads", { session })),
|
||||
debugUnityProcesses: () => typedError<AttachableProcess[], IdeError>(__TAURI_INVOKE("debug_unity_processes")),
|
||||
debugVariables: (session: DebugSessionId, reference: number) => typedError<Variable[], IdeError>(__TAURI_INVOKE("debug_variables", { session, reference })),
|
||||
debugVariables: (session: DebugSessionId, reference: number) => typedError<Variable_Serialize[], IdeError>(__TAURI_INVOKE("debug_variables", { session, reference })),
|
||||
dependencyVersions: (doc: DocId, offset: number | null, request: RequestId) => typedError<DependencyVersions[], IdeError>(__TAURI_INVOKE("dependency_versions", { doc, offset, request })),
|
||||
deployCompare: (path: IpcPath, server: string | null, request: RequestId) => typedError<SyncEntry[], IdeError>(__TAURI_INVOKE("deploy_compare", { path, server, request })),
|
||||
deployCoverage: (paths: IpcPath[]) => typedError<DeploymentCoverage[], IdeError>(__TAURI_INVOKE("deploy_coverage", { paths })),
|
||||
@@ -1935,6 +1940,12 @@ export const commands = {
|
||||
windowCompleteLaunch: () => typedError<null, IdeError>(__TAURI_INVOKE("window_complete_launch")),
|
||||
/** Focuses the next / previous window (⌘` / ⇧⌘`). */
|
||||
windowCycle: (forward: boolean) => __TAURI_INVOKE<void>("window_cycle", { forward }),
|
||||
/**
|
||||
* Drags `paths` (local files and folders) out of `window` while the primary mouse button is
|
||||
* still down, so the app they are dropped on copies them (#2867). Resolves when the drag ends,
|
||||
* with whether a target took the files.
|
||||
*/
|
||||
windowDragFiles: (paths: string[]) => typedError<boolean, IdeError>(__TAURI_INVOKE("window_drag_files", { paths })),
|
||||
/**
|
||||
* Flash (`true`) or stop flashing (`false`) this window's taskbar button, like IDEA when a
|
||||
* breakpoint is hit while the window is in the background (macOS bounces the dock icon,
|
||||
@@ -2204,6 +2215,18 @@ export type AgentChangesView =
|
||||
/** What the last turn changed, against the checkout as that turn started. */
|
||||
"lastTurn";
|
||||
|
||||
export type AgentCliOffer = {
|
||||
current: string,
|
||||
latest: string,
|
||||
prefix: string,
|
||||
};
|
||||
|
||||
export type AgentCliUpdateResult = {
|
||||
status: "available",
|
||||
} & AgentCliOffer | {
|
||||
status: "permission",
|
||||
} & AgentCliOffer | ({ status: "current"; current: string }) & { code?: never } | ({ status: "channel"; current: string }) & { code?: never } | ({ status: "updated"; current: string }) & { code?: never } | ({ status: "unmanaged" }) & { code?: never; current?: never } | ({ status: "error"; code: string }) & { current?: never };
|
||||
|
||||
export type AgentCommand = {
|
||||
/** Without the leading `/`. */
|
||||
name: string,
|
||||
@@ -2560,6 +2583,8 @@ export type AgentProvider = {
|
||||
commandReadOnlyReason: AgentCommandReadOnlyReason | null,
|
||||
/** Whether the command was found (on `PATH`). */
|
||||
installed: boolean,
|
||||
/** The built-in command can be owned by a global npm package. */
|
||||
canCheckCliUpdate?: boolean,
|
||||
/** Environment variables it starts with (from its agent file). */
|
||||
env: { [key in string]: string },
|
||||
/** Settings (models, modes…) the agent offered last time it ran; empty before its first session. */
|
||||
@@ -3824,6 +3849,8 @@ export type Commit_Deserialize = {
|
||||
historyPath?: string | null,
|
||||
logPosition?: number | null,
|
||||
logTotal?: number | null,
|
||||
/** Newest committer time at or after this row if newer than the row's commit. */
|
||||
logMergeTimeMs?: number | null,
|
||||
graphBoundaryParents?: string[],
|
||||
/** Reachability from HEAD, computed independently of the visible filters. */
|
||||
onCurrentBranch?: boolean | null,
|
||||
@@ -3853,6 +3880,8 @@ export type Commit_Serialize = {
|
||||
historyPath?: string | null,
|
||||
logPosition?: number | null,
|
||||
logTotal?: number | null,
|
||||
/** Newest committer time at or after this row if newer than the row's commit. */
|
||||
logMergeTimeMs?: number | null,
|
||||
graphBoundaryParents?: string[],
|
||||
/** Reachability from HEAD, computed independently of the visible filters. */
|
||||
onCurrentBranch?: boolean | null,
|
||||
@@ -6282,9 +6311,12 @@ export type FoldRange = {
|
||||
kind: FoldKind,
|
||||
};
|
||||
|
||||
export type FoldingOutlineVisibility = "hover" | "always";
|
||||
|
||||
/** Editor › General › Code Folding. */
|
||||
export type FoldingSettings = {
|
||||
showOutline?: boolean,
|
||||
outlineVisibility?: FoldingOutlineVisibility,
|
||||
fileHeader?: boolean,
|
||||
imports?: boolean,
|
||||
docComments?: boolean,
|
||||
@@ -12352,13 +12384,34 @@ export type UpdateStatus = {
|
||||
checking: boolean,
|
||||
};
|
||||
|
||||
export type Variable = {
|
||||
export type Variable = Variable_Serialize | Variable_Deserialize;
|
||||
|
||||
export type Variable_Deserialize = {
|
||||
name: string,
|
||||
value: string,
|
||||
typeName: string | null,
|
||||
/** > 0 when expandable. */
|
||||
variablesReference: number,
|
||||
evaluateName: string | null,
|
||||
/**
|
||||
* `value` is not computed yet (DAP `presentationHint.lazy`): the single variable that
|
||||
* `variables` returns for `variables_reference` holds the value and its children.
|
||||
*/
|
||||
lazy?: boolean,
|
||||
};
|
||||
|
||||
export type Variable_Serialize = {
|
||||
name: string,
|
||||
value: string,
|
||||
typeName: string | null,
|
||||
/** > 0 when expandable. */
|
||||
variablesReference: number,
|
||||
evaluateName: string | null,
|
||||
/**
|
||||
* `value` is not computed yet (DAP `presentationHint.lazy`): the single variable that
|
||||
* `variables` returns for `variables_reference` holds the value and its children.
|
||||
*/
|
||||
lazy?: boolean,
|
||||
};
|
||||
|
||||
/** Version Control › Confirmation. */
|
||||
@@ -12400,6 +12453,8 @@ export type VcsRoot = {
|
||||
export type VcsSettings = {
|
||||
/** Colour folders that contain changed files (project tree, tabs). */
|
||||
showDirtyDirectories?: boolean,
|
||||
/** Diffs the user opens show in an editor tab; off, in a separate window. */
|
||||
diffAsEditorTab?: boolean,
|
||||
/** Stop file history (Show History) after `history_limit` commits. */
|
||||
limitHistory?: boolean,
|
||||
historyLimit?: number,
|
||||
|
||||
@@ -68,6 +68,7 @@ import { cloneCaretAbove, cloneCaretBelow } from "./cm/verticalMotion";
|
||||
import { pasteAsPlainText, pasteFromHistory, unwrapAtCaret } from "./extras";
|
||||
import { cyclicExpandWord } from "./wordCompletion";
|
||||
import { copyReferenceToClipboard, declaredName, qualifiedReference, referenceOffset } from "./copyReference";
|
||||
import { selectedLineContext, selectedLines } from "./selectedLines";
|
||||
import { declarationChain } from "./view/outline";
|
||||
import { recordClipboard } from "./clipboardHistory";
|
||||
import { useDocMeta, useOutline } from "./model/document";
|
||||
@@ -589,15 +590,6 @@ function copyReference(reference: Promise<string>) {
|
||||
}
|
||||
}
|
||||
|
||||
/** The selected lines (1-based), leaving out the one a selection ends at the start of. */
|
||||
function selectedLines(state: EditorState): { first: number; last: number } {
|
||||
const { doc, selection } = state;
|
||||
const { from, to } = selection.main;
|
||||
const first = doc.lineAt(from).number;
|
||||
const last = Math.max(first, doc.lineAt(to).number - (to > from && doc.lineAt(to).from === to ? 1 : 0));
|
||||
return { first, last };
|
||||
}
|
||||
|
||||
/** `path:12`, or `path:12-18` for a selection over several lines. */
|
||||
function pathWithLines(state: EditorState, path: string): string {
|
||||
const { first, last } = selectedLines(state);
|
||||
@@ -606,11 +598,9 @@ function pathWithLines(state: EditorState, path: string): string {
|
||||
|
||||
function copyPathReferencePopup(view: EditorView, slot: EditorSlot) {
|
||||
const path = slot.model.path;
|
||||
const { first, last } = selectedLines(view.state);
|
||||
const contributed = menuGroupItems("copyPath", {
|
||||
paths: [path],
|
||||
line: first - 1,
|
||||
endLine: last > first ? last - 1 : undefined,
|
||||
...selectedLineContext(view.state),
|
||||
}).flatMap((item) =>
|
||||
(item.kind ?? "item") === "item" && "run" in item && item.id && item.run && item.preview
|
||||
? [
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
/**
|
||||
* Folding: ranges from the backend (`doc_folding`, tree-sitter based) merged
|
||||
* with CodeMirror's syntax folding (`foldNodeProp`) as fallback, IDEA-style
|
||||
* chevrons in the gutter (open chevrons only on gutter hover).
|
||||
* chevrons in the gutter (open chevrons can be shown only on hover).
|
||||
*/
|
||||
import {
|
||||
EditorSelection,
|
||||
@@ -23,6 +23,7 @@ import {
|
||||
unfoldEffect,
|
||||
} from "@codemirror/language";
|
||||
import type { FoldRange } from "@/platform/ipc";
|
||||
import type { FoldingOutlineVisibility } from "@/bindings";
|
||||
import { enclosingCodeBlock } from "./caretCommands";
|
||||
import { regionMarkerAt, regionNameAt } from "./regions";
|
||||
|
||||
@@ -432,9 +433,10 @@ export const expandRecursively = (view: EditorView) =>
|
||||
view.state.selection.ranges.flatMap((r) => expandRecursivelyEffects(view.state, r.head)),
|
||||
);
|
||||
|
||||
function chevron(open: boolean): HTMLElement {
|
||||
function chevron(open: boolean, visibility: FoldingOutlineVisibility): HTMLElement {
|
||||
const span = document.createElement("span");
|
||||
span.className = open ? "cm-openidea-foldOpen" : "cm-openidea-foldClosed";
|
||||
span.classList.toggle("cm-openidea-foldOnHover", open && visibility === "hover");
|
||||
span.title = open ? "Collapse" : "Expand";
|
||||
const ns = "http://www.w3.org/2000/svg";
|
||||
const svg = document.createElementNS(ns, "svg");
|
||||
@@ -477,10 +479,14 @@ export function foldChipWidth(el: HTMLElement): number {
|
||||
return Math.round(chip.getBoundingClientRect().width);
|
||||
}
|
||||
|
||||
export function foldingExtension(showOutline = true): Extension {
|
||||
export function foldingExtension(showOutline = true, visibility: FoldingOutlineVisibility = "hover"): Extension {
|
||||
return [
|
||||
// The chevron column sits right of contributed icon gutters (IDEA new UI).
|
||||
showOutline ? Prec.lowest(foldGutter({ markerDOM: chevron, foldingChanged: backendFoldingChanged })) : [],
|
||||
showOutline
|
||||
? Prec.lowest(
|
||||
foldGutter({ markerDOM: (open) => chevron(open, visibility), foldingChanged: backendFoldingChanged }),
|
||||
)
|
||||
: [],
|
||||
backendFolds,
|
||||
backendFoldService,
|
||||
codeFolding({
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { ensureSyntaxTree, syntaxTree } from "@codemirror/language";
|
||||
import { javascript } from "@codemirror/lang-javascript";
|
||||
import { EditorState } from "@codemirror/state";
|
||||
|
||||
/** Functions with long doc comments: re-parsing reuses a whole comment as one node. */
|
||||
const source = Array.from(
|
||||
{ length: 5 },
|
||||
(_, i) =>
|
||||
`/**\n${Array.from({ length: 40 }, (_, j) => ` * line ${j} of the comment on f${i}\n`).join("")} */\n` +
|
||||
`export const f${i} = (a, b = {}) => {\n // body\n if (a) return b\n return a\n}\n\n`,
|
||||
).join("");
|
||||
|
||||
describe("incremental parsing (#4468)", () => {
|
||||
it("keeps a reused comment out of the declaration before it", () => {
|
||||
let state = EditorState.create({ doc: source, extensions: [javascript()] });
|
||||
ensureSyntaxTree(state, state.doc.length, 5000);
|
||||
// Reindenting, as a formatter does.
|
||||
const at = source.indexOf(" // body");
|
||||
state = state.update({ changes: { from: at, to: at + 4, insert: " " } }).state;
|
||||
const tree = ensureSyntaxTree(state, state.doc.length, 5000) ?? syntaxTree(state);
|
||||
const fresh = javascript().language.parser.parse(state.doc.toString());
|
||||
expect(tree.toString()).toBe(fresh.toString());
|
||||
expect(tree.topNode.firstChild?.name).toBe("BlockComment");
|
||||
expect(tree.topNode.firstChild?.from).toBe(0);
|
||||
});
|
||||
});
|
||||
@@ -276,7 +276,8 @@ export function distractionFreeExtension(
|
||||
}
|
||||
|
||||
export function foldingFor(settings: EditorSettings | undefined): Extension {
|
||||
return foldingExtension(prefsOf(settings).folding.showOutline);
|
||||
const { showOutline, outlineVisibility } = prefsOf(settings).folding;
|
||||
return foldingExtension(showOutline, outlineVisibility);
|
||||
}
|
||||
|
||||
export function caretFor(settings: EditorSettings | undefined): Extension {
|
||||
|
||||
@@ -303,9 +303,9 @@ export const openideaTheme = EditorView.theme({
|
||||
cursor: "pointer",
|
||||
transition: "opacity var(--dur-fast) var(--ease)",
|
||||
},
|
||||
".cm-foldGutter .cm-openidea-foldOpen": { opacity: "0", display: "inline-flex" },
|
||||
".cm-foldGutter .cm-openidea-foldClosed": { display: "inline-flex" },
|
||||
".cm-gutters:hover .cm-foldGutter .cm-openidea-foldOpen": { opacity: "1" },
|
||||
".cm-foldGutter .cm-openidea-foldOpen, .cm-foldGutter .cm-openidea-foldClosed": { display: "inline-flex" },
|
||||
".cm-foldGutter .cm-openidea-foldOnHover": { opacity: "0" },
|
||||
".cm-gutters:hover .cm-foldGutter .cm-openidea-foldOnHover": { opacity: "1" },
|
||||
".cm-foldGutter .cm-gutterElement:hover": { color: "var(--fg-secondary)" },
|
||||
".cm-foldPlaceholder": {
|
||||
backgroundColor: "var(--editor-fold-chip)",
|
||||
|
||||
@@ -115,6 +115,7 @@ import { isClassFile } from "@/platform/classFiles";
|
||||
import { isVirtualUri, virtualDocument } from "@/platform/virtualDocs";
|
||||
import type { VirtualDocument } from "@/platform/ipc";
|
||||
import type { Scheduler } from "./sync/DocSync";
|
||||
import { selectedLineContext } from "./selectedLines";
|
||||
|
||||
export const fileKey = (path: string) => `file:${path}`;
|
||||
export const fileInput = (path: string): EditorInput => ({ kind: "file", key: fileKey(path), path });
|
||||
@@ -994,7 +995,7 @@ export class EditorController implements SlotHost {
|
||||
] as MenuItem[])
|
||||
: ([
|
||||
{ kind: "separator" },
|
||||
openInMenu(slot.model.path, view.state.doc.lineAt(view.state.selection.main.head).number - 1),
|
||||
openInMenu(slot.model.path, selectedLineContext(view.state)),
|
||||
{ kind: "separator" },
|
||||
localHistoryMenu(slot.model.path),
|
||||
gitMenu(slot.model.path),
|
||||
@@ -2352,7 +2353,7 @@ export class EditorController implements SlotHost {
|
||||
}
|
||||
|
||||
/** Open In › for a file: Project View, Finder / Explorer / Files, associated app, Terminal. */
|
||||
function openInMenu(path: string, line?: number): MenuItem {
|
||||
function openInMenu(path: string, lines?: { line: number; endLine?: number }): MenuItem {
|
||||
return {
|
||||
label: "Open In",
|
||||
submenu: [
|
||||
@@ -2372,7 +2373,7 @@ function openInMenu(path: string, line?: number): MenuItem {
|
||||
: []),
|
||||
{ kind: "action", action: "project.openInTerminal", arg: path, label: "Terminal" },
|
||||
{ kind: "separator" },
|
||||
...menuGroupItems("openIn", { paths: [path], line }),
|
||||
...menuGroupItems("openIn", { paths: [path], ...lines }),
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
@@ -239,6 +239,36 @@ describe("editor Copy Path/Reference chooser", () => {
|
||||
]);
|
||||
});
|
||||
|
||||
it("gives Open In contributions the selected lines", () => {
|
||||
const contexts: MenuGroupContext[] = [];
|
||||
disposers.push(
|
||||
registerMenuGroup({
|
||||
id: "test.openIn",
|
||||
menus: ["openIn"],
|
||||
items: (_menu, ctx) => {
|
||||
contexts.push(ctx);
|
||||
return [];
|
||||
},
|
||||
}),
|
||||
);
|
||||
const view = ctrl.activeSlot!.view!;
|
||||
vi.spyOn(view, "posAtCoords").mockReturnValue(null);
|
||||
// The caret; a selection from the second line back into the first; one ending at the start of the second.
|
||||
for (const selection of [
|
||||
{ anchor: documentText.indexOf("A {}") },
|
||||
{ anchor: documentText.indexOf("A {}"), head: 0 },
|
||||
{ anchor: 0, head: documentText.indexOf("class") },
|
||||
]) {
|
||||
view.dispatch({ selection });
|
||||
ctrl.onContextMenu(ctrl.activeSlot!, new MouseEvent("contextmenu"));
|
||||
}
|
||||
expect(contexts.map(({ paths, line, endLine }) => [paths, line, endLine])).toEqual([
|
||||
[[path], 1, undefined],
|
||||
[[path], 0, 1],
|
||||
[[path], 0, undefined],
|
||||
]);
|
||||
});
|
||||
|
||||
it("adds the chooser to Copy / Paste Special", () => {
|
||||
vi.spyOn(ctrl.activeSlot!.view!, "posAtCoords").mockReturnValue(null);
|
||||
ctrl.onContextMenu(ctrl.activeSlot!, new MouseEvent("contextmenu"));
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
import type { EditorState } from "@codemirror/state";
|
||||
|
||||
/** The main selection's lines (1-based), leaving out the one a selection ends at the start of, as IDEA. */
|
||||
export function selectedLines(state: EditorState): { first: number; last: number } {
|
||||
const { doc, selection } = state;
|
||||
const { from, to } = selection.main;
|
||||
const first = doc.lineAt(from).number;
|
||||
const last = Math.max(first, doc.lineAt(to).number - (to > from && doc.lineAt(to).from === to ? 1 : 0));
|
||||
return { first, last };
|
||||
}
|
||||
|
||||
/** The selected lines as a menu group's 0-based `line` / `endLine` (absent for a single line). */
|
||||
export function selectedLineContext(state: EditorState): { line: number; endLine?: number } {
|
||||
const { first, last } = selectedLines(state);
|
||||
return { line: first - 1, endLine: last > first ? last - 1 : undefined };
|
||||
}
|
||||
@@ -28,6 +28,7 @@ import {
|
||||
import {
|
||||
acceptCompletion,
|
||||
closeCompletion,
|
||||
completionStatus,
|
||||
currentCompletions,
|
||||
snippet,
|
||||
startCompletion,
|
||||
@@ -840,6 +841,38 @@ describe("completion footer", () => {
|
||||
view = null;
|
||||
});
|
||||
|
||||
it("formats partial results while the language server is still answering", async () => {
|
||||
let finishReply = () => {};
|
||||
const reply = new Promise((resolve) => {
|
||||
finishReply = () => resolve({ isIncomplete: false, items: [] });
|
||||
});
|
||||
setInvokeRoute((cmd) => (cmd === "lsp_completion" ? reply : Promise.resolve(null)));
|
||||
const source: CompletionSource = (ctx) => ({ from: ctx.pos, options: [{ label: "localSuggestion" }] });
|
||||
view = new EditorView({
|
||||
state: EditorState.create({
|
||||
doc: "thing.",
|
||||
selection: { anchor: 6 },
|
||||
extensions: [
|
||||
lspDoc.of({ doc: 902, path: "/p/Example.java", language: "java", uiMode: "Java", readOnly: false }),
|
||||
completionExtension(),
|
||||
EditorState.languageData.of(() => [{ openideaCompletion: source }]),
|
||||
],
|
||||
}),
|
||||
parent: document.body,
|
||||
});
|
||||
try {
|
||||
startCompletion(view);
|
||||
await vi.waitFor(() => {
|
||||
expect(completionStatus(view!.state)).toBe("pending");
|
||||
expect(document.querySelector(".cm-tooltip-autocomplete > .cm-lsp-completion-footer")).not.toBeNull();
|
||||
});
|
||||
} finally {
|
||||
closeCompletion(view);
|
||||
setInvokeRoute(null);
|
||||
finishReply();
|
||||
}
|
||||
});
|
||||
|
||||
it("stays below the list after CodeMirror rebuilds the options", async () => {
|
||||
const source: CompletionSource = (ctx) => ({
|
||||
from: ctx.pos,
|
||||
|
||||
@@ -25,7 +25,16 @@ import {
|
||||
type CompletionSource,
|
||||
} from "@codemirror/autocomplete";
|
||||
import { EditorSelection, EditorState, Prec, StateEffect, StateField, type Text } from "@codemirror/state";
|
||||
import { EditorView, ViewPlugin, getTooltip, keymap, showTooltip, type Rect, type ViewUpdate } from "@codemirror/view";
|
||||
import {
|
||||
EditorView,
|
||||
ViewPlugin,
|
||||
getTooltip,
|
||||
keymap,
|
||||
repositionTooltips,
|
||||
showTooltip,
|
||||
type Rect,
|
||||
type ViewUpdate,
|
||||
} from "@codemirror/view";
|
||||
import {
|
||||
call,
|
||||
commands,
|
||||
@@ -989,7 +998,14 @@ const completionPopup = ViewPlugin.fromClass(
|
||||
class {
|
||||
constructor(private view: EditorView) {}
|
||||
update(u: ViewUpdate) {
|
||||
if (completionStatus(u.state) !== "active") return;
|
||||
// The lookup can show partial results while another source is still pending.
|
||||
const popup = u.state
|
||||
.facet(showTooltip)
|
||||
.map((tooltip) => tooltip && getTooltip(this.view, tooltip))
|
||||
.find((tooltip) => tooltip?.dom.classList.contains("cm-lsp-completion"));
|
||||
if (!popup) return;
|
||||
popup.offset ??= { x: -completionLabelOffset, y: 0 };
|
||||
const t = popup.dom;
|
||||
this.view.requestMeasure({
|
||||
key: this,
|
||||
read: () => {
|
||||
@@ -1000,19 +1016,12 @@ const completionPopup = ViewPlugin.fromClass(
|
||||
};
|
||||
},
|
||||
write: ({ width, fontSize }) => {
|
||||
const popup = this.view.state
|
||||
.facet(showTooltip)
|
||||
.map((tooltip) => tooltip && getTooltip(this.view, tooltip))
|
||||
.find((tooltip) => tooltip?.dom.classList.contains("cm-lsp-completion"));
|
||||
if (!popup) return;
|
||||
// Apply the label alignment inside CodeMirror's viewport clamp.
|
||||
popup.offset = { x: -completionLabelOffset, y: 0 };
|
||||
const t = popup.dom;
|
||||
if (t.style.getPropertyValue("--cm-completion-max-width") !== width)
|
||||
t.style.setProperty("--cm-completion-max-width", width);
|
||||
if (!t.isConnected) return;
|
||||
const widthChanged = t.style.getPropertyValue("--cm-completion-max-width") !== width;
|
||||
if (widthChanged) t.style.setProperty("--cm-completion-max-width", width);
|
||||
// The body-level tooltip does not inherit the editor's temporary font zoom.
|
||||
if (t.style.getPropertyValue("--openidea-editor-font-size") !== fontSize)
|
||||
t.style.setProperty("--openidea-editor-font-size", fontSize);
|
||||
const fontChanged = t.style.getPropertyValue("--openidea-editor-font-size") !== fontSize;
|
||||
if (fontChanged) t.style.setProperty("--openidea-editor-font-size", fontSize);
|
||||
let footer = t.querySelector<HTMLElement>(":scope > .cm-lsp-completion-footer");
|
||||
if (!footer) {
|
||||
footer = document.createElement("div");
|
||||
@@ -1023,7 +1032,10 @@ const completionPopup = ViewPlugin.fromClass(
|
||||
}
|
||||
// CodeMirror appends a fresh list when the candidates change.
|
||||
const list = t.querySelector(":scope > ul");
|
||||
if (list && list.nextElementSibling !== footer) list.after(footer);
|
||||
const footerMoved = list && list.nextElementSibling !== footer;
|
||||
if (footerMoved) list.after(footer);
|
||||
// CodeMirror has already measured the lookup. Reposition it before this frame paints.
|
||||
if (widthChanged || fontChanged || footerMoved) repositionTooltips(this.view);
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
@@ -30,6 +30,7 @@ describe("pending hints", () => {
|
||||
vi.advanceTimersByTime(PENDING_HINT_DELAY_MS);
|
||||
expect(hint()).toBe("Waiting…");
|
||||
expect(document.querySelector<HTMLElement>(".cm-lsp-hint")?.dataset.pending).toBe("true");
|
||||
expect(document.querySelector(".cm-lsp-hint .cm-lsp-hint-spinner svg")).not.toBeNull();
|
||||
done();
|
||||
expect(hint()).toBeNull();
|
||||
});
|
||||
@@ -37,6 +38,7 @@ describe("pending hints", () => {
|
||||
it("marks only progress as pending", () => {
|
||||
showHint(view, "Done");
|
||||
expect(document.querySelector<HTMLElement>(".cm-lsp-hint")?.dataset.pending).toBeUndefined();
|
||||
expect(document.querySelector(".cm-lsp-hint-spinner")).toBeNull();
|
||||
});
|
||||
|
||||
it("puts what the hint answers in its data attributes", () => {
|
||||
|
||||
@@ -7,6 +7,7 @@ import { StateEffect, StateField, type Extension } from "@codemirror/state";
|
||||
import { EditorView, keymap, showTooltip, type Tooltip } from "@codemirror/view";
|
||||
import { Prec } from "@codemirror/state";
|
||||
import { txTemplate } from "@/platform/i18n";
|
||||
import { spinnerNode } from "@/ui/iconNode";
|
||||
|
||||
interface Hint {
|
||||
pos: number;
|
||||
@@ -48,6 +49,7 @@ const hintField = StateField.define<Hint | null>({
|
||||
Object.assign(dom.dataset, h.data);
|
||||
if (typeof h.content === "string") {
|
||||
dom.textContent = txTemplate(h.content);
|
||||
if (h.pending) dom.prepend(spinnerNode(12, "cm-lsp-hint-spinner"));
|
||||
return { dom };
|
||||
}
|
||||
const built = h.content();
|
||||
|
||||
@@ -335,6 +335,7 @@ export const lspTheme = EditorView.theme({
|
||||
boxShadow: "var(--shadow-popup)",
|
||||
whiteSpace: "pre-wrap",
|
||||
},
|
||||
".cm-lsp-hint-spinner": { display: "inline-flex", verticalAlign: "-2px", marginRight: "var(--space-2)" },
|
||||
// The hint is the tooltip element itself: beat the editor theme's `.cm-tooltip` width.
|
||||
".cm-tooltip.cm-lsp-hint": { maxWidth: "min(480px, 100%)" },
|
||||
".cm-lsp-hint-error": {
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
.summary {
|
||||
display: grid;
|
||||
gap: var(--space-2);
|
||||
}
|
||||
.title {
|
||||
margin: 0;
|
||||
font-size: inherit;
|
||||
font-weight: 600;
|
||||
}
|
||||
.detail {
|
||||
margin: 0;
|
||||
padding: var(--space-3);
|
||||
border: 1px solid var(--border);
|
||||
border-radius: var(--radius-control);
|
||||
color: var(--fg-secondary);
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
import type { Location } from "@/bindings";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { ask } from "@/workbench/messages";
|
||||
import styles from "./SafeDeleteUsages.module.css";
|
||||
|
||||
type UsagesAnswer = "view" | "delete" | "cancel";
|
||||
|
||||
/** `subject`: "Function 'foo'", "File 'a.ts'", "3 files" (`plural`). */
|
||||
export function usagesMessage(
|
||||
subject: string,
|
||||
usages: readonly Location[],
|
||||
plural = false,
|
||||
): { message: string; detail: string } {
|
||||
const n = usages.length;
|
||||
const files = new Set(usages.map((u) => u.path)).size;
|
||||
const where = files > 1 ? tx` (in ${files} files)` : "";
|
||||
let detail: string;
|
||||
if (plural)
|
||||
detail =
|
||||
n === 1
|
||||
? tx`${subject} have ${n} usage that is not safe to delete${where}.`
|
||||
: tx`${subject} have ${n} usages that are not safe to delete${where}.`;
|
||||
else
|
||||
detail =
|
||||
n === 1
|
||||
? tx`${subject} has ${n} usage that is not safe to delete${where}.`
|
||||
: tx`${subject} has ${n} usages that are not safe to delete${where}.`;
|
||||
return { message: n === 1 ? tx`${n} usage found` : tx`${n} usages found`, detail };
|
||||
}
|
||||
|
||||
export async function askUsagesDetected(
|
||||
subject: string,
|
||||
usages: readonly Location[],
|
||||
plural = false,
|
||||
): Promise<UsagesAnswer> {
|
||||
const { message, detail } = usagesMessage(subject, usages, plural);
|
||||
const { button } = await ask({
|
||||
title: "Usages Detected",
|
||||
presentation: "form",
|
||||
width: 540,
|
||||
body: (
|
||||
<div className={styles.summary}>
|
||||
<h2 className={styles.title}>{message}</h2>
|
||||
<p className={styles.detail}>{detail}</p>
|
||||
</div>
|
||||
),
|
||||
buttons: [
|
||||
{ id: "view", label: "View Usages", primary: true },
|
||||
{ id: "delete", label: "Delete Anyway" },
|
||||
],
|
||||
});
|
||||
return button === "view" || button === "delete" ? button : "cancel";
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
export { refactorThis, runRefactoring, showNothingHere } from "./refactorThis";
|
||||
export { askUsagesDetected, fileUsages, safeDelete, viewUsages } from "./safeDelete";
|
||||
export { fileUsages, safeDelete, viewUsages } from "./safeDelete";
|
||||
export { askUsagesDetected } from "./SafeDeleteUsages";
|
||||
export { startHierarchyRefactoring } from "./hierarchy";
|
||||
export { ChangeSignatureDialog } from "./ChangeSignatureDialog";
|
||||
export { JAVA_REFACTORING_COMMAND, runJavaRefactoringCommand } from "./javaMove";
|
||||
|
||||
@@ -2,7 +2,8 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { EditorState, Text } from "@codemirror/state";
|
||||
import { EditorView } from "@codemirror/view";
|
||||
import { history, undo } from "@codemirror/commands";
|
||||
import type { MessageRequest } from "@/workbench/messages";
|
||||
import { render } from "@testing-library/react";
|
||||
import type { ConfirmOptions, MessageRequest } from "@/workbench/messages";
|
||||
import type { LocalSymbol, Location, Locals, OutlineItem, Pos, Range, StructuralRanges, SyntaxNode } from "@/bindings";
|
||||
|
||||
// --- backend fakes ---------------------------------------------------------
|
||||
@@ -74,13 +75,12 @@ vi.mock("@tauri-apps/api/core", async (orig) => ({
|
||||
let answer = "cancel";
|
||||
const ask = vi.fn(async (_request: MessageRequest) => ({ button: answer, checked: false }));
|
||||
let confirmAnswer: { checked: boolean } | null = { checked: false };
|
||||
const confirmChecked = vi.fn(
|
||||
async (_opts: { title: string; message: string; checkbox?: string; checked?: boolean }) => confirmAnswer,
|
||||
);
|
||||
const confirmChecked = vi.fn(async (_opts: ConfirmOptions) => confirmAnswer);
|
||||
vi.mock("@/workbench/messages", () => ({ ask, confirmChecked }));
|
||||
|
||||
const { deletionRange, localDeclaration, outlineItemAt, safeDelete, fileUsages, usagesMessage, textOccurrences } =
|
||||
const { deletionRange, localDeclaration, outlineItemAt, safeDelete, fileUsages, textOccurrences } =
|
||||
await import("./safeDelete");
|
||||
const { usagesMessage } = await import("./SafeDeleteUsages");
|
||||
const { closePopup, useLspPopup } = await import("@/editor/lsp/popupStore");
|
||||
const { lspDoc } = await import("@/editor/lsp/lsp");
|
||||
|
||||
@@ -294,7 +294,11 @@ describe("safeDelete in the editor", () => {
|
||||
await safeDelete(v);
|
||||
const request = ask.mock.calls[0]![0];
|
||||
expect(request.title).toBe("Usages Detected");
|
||||
expect(request.body).toBe("1 usage found\nFunction 'used' has 1 usage that is not safe to delete.");
|
||||
expect(request.presentation).toBe("form");
|
||||
const summary = render(request.body);
|
||||
expect(summary.getByRole("heading", { name: "1 usage found" })).toBeInTheDocument();
|
||||
expect(summary.getByText("Function 'used' has 1 usage that is not safe to delete.")).toBeInTheDocument();
|
||||
summary.unmount();
|
||||
expect(request.buttons.map((b) => b.label)).toEqual(["View Usages", "Delete Anyway"]);
|
||||
return v;
|
||||
};
|
||||
@@ -314,6 +318,7 @@ describe("safeDelete in the editor", () => {
|
||||
expect(confirmChecked).toHaveBeenCalledTimes(1);
|
||||
const opts = confirmChecked.mock.calls[0]![0];
|
||||
expect(opts.title).toBe("Safe Delete");
|
||||
expect(opts.presentation).toBe("form");
|
||||
expect(opts.message).toBe("Delete Function 'unused'?");
|
||||
expect(opts.checkbox).toBe("Search in comments and strings");
|
||||
expect(lspReferences).not.toHaveBeenCalled();
|
||||
|
||||
Loaded 100 of 205 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача