Порівняти коміти

..
Автор SHA1 Повідомлення Дата
l0ng-ai ad7d87710c test(e2e): follow the split panes of the Inspections and Plugins settings
#4629 and #4636 put both pages' list and details into resizable split
panels, so the details and the profile label are no longer direct
children of the containers the shared settings layout specs selected.
2026-11-20 17:44:21 +08:00
298 змінених файлів з 1809 додано та 11840 видалено

No files matched your search

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