дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-21 17:10:45 +02:00
Порівняти коміти
1
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
cb9618165a |
No files matched your search
Створено
-18
@@ -4156,8 +4156,6 @@ dependencies = [
|
||||
"ide-vcs",
|
||||
"ide-vfs",
|
||||
"parking_lot",
|
||||
"rustix",
|
||||
"semver",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"specta",
|
||||
@@ -4359,20 +4357,6 @@ dependencies = [
|
||||
"which",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-drag-out"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"gtk",
|
||||
"objc2 0.6.5",
|
||||
"objc2-app-kit 0.3.2",
|
||||
"objc2-foundation 0.3.2",
|
||||
"raw-window-handle",
|
||||
"tempfile",
|
||||
"windows",
|
||||
"windows-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-extension"
|
||||
version = "0.1.49"
|
||||
@@ -4527,7 +4511,6 @@ dependencies = [
|
||||
name = "ide-http"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"hyper-util",
|
||||
"ide-core",
|
||||
"ide-vfs",
|
||||
"parking_lot",
|
||||
@@ -6714,7 +6697,6 @@ dependencies = [
|
||||
"ide-dap",
|
||||
"ide-db",
|
||||
"ide-docker",
|
||||
"ide-drag-out",
|
||||
"ide-extension",
|
||||
"ide-fonts",
|
||||
"ide-github",
|
||||
|
||||
@@ -38,7 +38,6 @@ ide-web = { path = "crates/ide-web" }
|
||||
ide-spell = { path = "crates/ide-spell" }
|
||||
ide-agent = { path = "crates/ide-agent" }
|
||||
ide-clipboard = { path = "crates/ide-clipboard" }
|
||||
ide-drag-out = { path = "crates/ide-drag-out" }
|
||||
ide-fonts = { path = "crates/ide-fonts" }
|
||||
ide-ssh = { path = "crates/ide-ssh" }
|
||||
ide-remote = { path = "crates/ide-remote" }
|
||||
|
||||
@@ -25,10 +25,6 @@ dunce.workspace = true
|
||||
uuid.workspace = true
|
||||
tempfile.workspace = true
|
||||
which = "8"
|
||||
semver = "1"
|
||||
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
rustix = { version = "1", features = ["fs"] }
|
||||
|
||||
[dev-dependencies]
|
||||
tokio = { workspace = true, features = ["test-util"] }
|
||||
@@ -1,395 +0,0 @@
|
||||
//! Checks and updates only the global npm installation selected by the agent launcher.
|
||||
use crate::{AgentManager, AgentSource, provider};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, error::ErrorKind};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
use specta::Type;
|
||||
use std::{
|
||||
fs, io,
|
||||
path::{Path, PathBuf},
|
||||
process::Command,
|
||||
};
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
pub struct AgentCliOffer {
|
||||
pub current: String,
|
||||
pub latest: String,
|
||||
pub prefix: PathBuf,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "status", rename_all = "camelCase")]
|
||||
pub enum AgentCliUpdateResult {
|
||||
Available(AgentCliOffer),
|
||||
Permission(AgentCliOffer),
|
||||
Current { current: String },
|
||||
Channel { current: String },
|
||||
Updated { current: String },
|
||||
Unmanaged,
|
||||
Error { code: String },
|
||||
}
|
||||
|
||||
pub(crate) fn package(id: &str) -> Option<&'static str> {
|
||||
Some(match id {
|
||||
"claude" => "@anthropic-ai/claude-code",
|
||||
"codex" => "@openai/codex",
|
||||
"gemini" => "@google/gemini-cli",
|
||||
"opencode" => "opencode-ai",
|
||||
"copilot" => "@github/copilot",
|
||||
"qwen" => "@qwen-code/qwen-code",
|
||||
"auggie" => "@augmentcode/auggie",
|
||||
"qoder" => "@qoder-ai/qodercli",
|
||||
"omp" => "@oh-my-pi/pi-coding-agent",
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
impl AgentManager {
|
||||
pub fn cli_update(
|
||||
&self,
|
||||
id: &str,
|
||||
offer: Option<&AgentCliOffer>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
let spec = self.shared.spec(id).ok_or_else(|| IdeError::invalid(format!("unknown agent {id}")))?;
|
||||
let (Some(pkg), Some(builtin)) = (package(id), provider::builtin_spec(id)) else {
|
||||
return Ok(AgentCliUpdateResult::Unmanaged);
|
||||
};
|
||||
if spec.source != AgentSource::Builtin {
|
||||
return Ok(AgentCliUpdateResult::Unmanaged);
|
||||
}
|
||||
let Ok(npm) = which::which("npm") else { return Ok(AgentCliUpdateResult::Unmanaged) };
|
||||
let program = spec.resolve_for_launch(&self.shared.paths.project_root).command;
|
||||
match maintain(&npm, Path::new(&program), &builtin.command, pkg, offer, cancel) {
|
||||
Err(e) if e.kind == ErrorKind::Unavailable => Ok(AgentCliUpdateResult::Error { code: e.message }),
|
||||
result => result,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct Installation {
|
||||
modules: PathBuf,
|
||||
folder: PathBuf,
|
||||
link: PathBuf,
|
||||
}
|
||||
|
||||
impl Installation {
|
||||
fn at(prefix: &Path, pkg: &str, bin: &str) -> Self {
|
||||
let modules = prefix.join(if cfg!(windows) { "node_modules" } else { "lib/node_modules" });
|
||||
let link = if cfg!(windows) { prefix.join(format!("{bin}.cmd")) } else { prefix.join("bin").join(bin) };
|
||||
Self { folder: modules.join(pkg), modules, link }
|
||||
}
|
||||
|
||||
fn version(&self, program: &Path, pkg: &str, bin: &str) -> IdeResult<Option<String>> {
|
||||
if !program.is_absolute() || !self.folder.try_exists()? || !self.link.try_exists()? || !program.try_exists()? {
|
||||
return Ok(None);
|
||||
}
|
||||
let folder = dunce::canonicalize(&self.folder)?;
|
||||
if fs::symlink_metadata(&self.folder)?.is_symlink()
|
||||
|| dunce::canonicalize(program)? != dunce::canonicalize(&self.link)?
|
||||
{
|
||||
return Ok(None);
|
||||
}
|
||||
let manifest = self.folder.join("package.json");
|
||||
if !manifest.try_exists()? {
|
||||
return Ok(None);
|
||||
}
|
||||
let manifest: Value = serde_json::from_slice(&fs::read(manifest)?)
|
||||
.map_err(|_| IdeError::invalid("Invalid npm package manifest"))?;
|
||||
let entry = manifest["bin"].as_str().or_else(|| manifest["bin"][bin].as_str());
|
||||
let Some(entry) = entry.filter(|_| manifest["name"] == pkg) else { return Ok(None) };
|
||||
let Some(version) = manifest["version"].as_str() else {
|
||||
return Err(IdeError::invalid("Missing npm package version"));
|
||||
};
|
||||
let entry = folder.join(entry);
|
||||
if !entry.try_exists()? {
|
||||
return Ok(None);
|
||||
}
|
||||
let entry = dunce::canonicalize(entry)?;
|
||||
if !entry.starts_with(&folder) {
|
||||
return Ok(None);
|
||||
}
|
||||
#[cfg(unix)]
|
||||
let owns = fs::symlink_metadata(&self.link)?.is_symlink() && dunce::canonicalize(&self.link)? == entry;
|
||||
#[cfg(windows)]
|
||||
let owns = {
|
||||
let prefix = dunce::canonicalize(self.link.parent().unwrap())?;
|
||||
let Ok(target) = entry.strip_prefix(prefix) else { return Ok(None) };
|
||||
let needle = format!("%dp0%\\{}\"", target.display()).to_lowercase();
|
||||
fs::read_to_string(&self.link)?.replace('/', "\\").to_lowercase().contains(&needle)
|
||||
};
|
||||
Ok(owns.then(|| version.to_owned()))
|
||||
}
|
||||
|
||||
fn writable(&self) -> io::Result<bool> {
|
||||
for dir in [&*self.folder, self.folder.parent().unwrap(), &self.modules, self.link.parent().unwrap()] {
|
||||
#[cfg(unix)]
|
||||
let access: io::Result<()> =
|
||||
rustix::fs::accessat(rustix::fs::CWD, dir, rustix::fs::Access::WRITE_OK, rustix::fs::AtFlags::empty())
|
||||
.map_err(Into::into);
|
||||
#[cfg(windows)]
|
||||
let access = tempfile::tempfile_in(dir).map(drop);
|
||||
match access {
|
||||
Err(e) if matches!(e.kind(), io::ErrorKind::PermissionDenied | io::ErrorKind::ReadOnlyFilesystem) => {
|
||||
return Ok(false);
|
||||
}
|
||||
other => other?,
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
fn stable(version: &str) -> Option<semver::Version> {
|
||||
semver::Version::parse(version).ok().filter(|v| v.pre.is_empty() && v.build.is_empty())
|
||||
}
|
||||
|
||||
fn maintain(
|
||||
npm: &Path,
|
||||
program: &Path,
|
||||
bin: &str,
|
||||
pkg: &str,
|
||||
approved: Option<&AgentCliOffer>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
use AgentCliUpdateResult::*;
|
||||
let run = |args: &[&str]| {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let mut cmd = Command::new(npm);
|
||||
cmd.args(args)
|
||||
.current_dir(npm.parent().unwrap())
|
||||
.env("NPM_CONFIG_UPDATE_NOTIFIER", "false")
|
||||
.env("NPM_CONFIG_LOGLEVEL", "error");
|
||||
ide_tools::run_streamed(cmd, cancel, &|_| {}).map_err(|e| {
|
||||
if e.kind == ErrorKind::Cancelled {
|
||||
return e;
|
||||
}
|
||||
// npm diagnostics can contain private registry URLs; expose only known codes.
|
||||
let code = e
|
||||
.message
|
||||
.split(|c: char| !c.is_ascii_alphanumeric() && c != '_')
|
||||
.find(|w| {
|
||||
matches!(
|
||||
*w,
|
||||
"EACCES"
|
||||
| "EPERM"
|
||||
| "EROFS"
|
||||
| "ENOTFOUND"
|
||||
| "EAI_AGAIN"
|
||||
| "ETIMEDOUT"
|
||||
| "E404"
|
||||
| "E401"
|
||||
| "E403"
|
||||
)
|
||||
})
|
||||
.unwrap_or("npm");
|
||||
IdeError::unavailable(code)
|
||||
})
|
||||
};
|
||||
let output = run(&["prefix", "-g"])?;
|
||||
let prefix = Path::new(output.trim_end());
|
||||
if !prefix.is_absolute() {
|
||||
return Err(IdeError::invalid("Invalid npm global prefix"));
|
||||
}
|
||||
let installation = Installation::at(prefix, pkg, bin);
|
||||
let Some(current) = installation.version(program, pkg, bin)? else { return Ok(Unmanaged) };
|
||||
let latest: String = serde_json::from_str(&run(&["view", &format!("{pkg}@latest"), "version", "--json"])?)
|
||||
.map_err(|_| IdeError::invalid("Invalid npm version response"))?;
|
||||
let (Some(before), Some(after)) = (stable(¤t), stable(&latest)) else {
|
||||
return Ok(Channel { current });
|
||||
};
|
||||
if before >= after {
|
||||
return Ok(Current { current });
|
||||
}
|
||||
let offer = AgentCliOffer { current, latest, prefix: prefix.to_owned() };
|
||||
if !installation.writable()? {
|
||||
return Ok(Permission(offer));
|
||||
}
|
||||
if approved != Some(&offer) {
|
||||
return Ok(Available(offer));
|
||||
}
|
||||
run(&[
|
||||
"install",
|
||||
"-g",
|
||||
"--prefix",
|
||||
prefix.to_str().unwrap(),
|
||||
"--no-audit",
|
||||
"--no-fund",
|
||||
&format!("{pkg}@{}", offer.latest),
|
||||
])?;
|
||||
if installation.version(program, pkg, bin)?.as_ref() != Some(&offer.latest) {
|
||||
return Err(IdeError::invalid("npm installation verification failed"));
|
||||
}
|
||||
Ok(Updated { current: offer.latest })
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
use tempfile::TempDir;
|
||||
|
||||
const PKG: &str = "@anthropic-ai/claude-code";
|
||||
|
||||
struct Fixture {
|
||||
root: TempDir,
|
||||
install: Installation,
|
||||
}
|
||||
|
||||
impl Fixture {
|
||||
fn new() -> Self {
|
||||
let root = tempfile::Builder::new().prefix("全局 prefix ").tempdir().unwrap();
|
||||
let install = Installation::at(root.path(), PKG, "claude");
|
||||
fs::create_dir_all(&install.folder).unwrap();
|
||||
fs::create_dir_all(install.link.parent().unwrap()).unwrap();
|
||||
fs::write(install.folder.join("entry.js"), "").unwrap();
|
||||
#[cfg(unix)]
|
||||
std::os::unix::fs::symlink(install.folder.join("entry.js"), &install.link).unwrap();
|
||||
#[cfg(windows)]
|
||||
fs::write(&install.link, r#"@"%dp0%\node_modules\@anthropic-ai\claude-code\entry.js""#).unwrap();
|
||||
let fixture = Self { root, install };
|
||||
fixture.manifest(PKG, "2.1.9");
|
||||
fixture
|
||||
}
|
||||
|
||||
fn manifest(&self, name: &str, version: &str) {
|
||||
fs::write(
|
||||
self.install.folder.join("package.json"),
|
||||
json!({"name":name,"version":version,"bin":{"claude":"entry.js"}}).to_string(),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
fn version(&self) -> Option<String> {
|
||||
self.install.version(&self.install.link, PKG, "claude").unwrap()
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn npm(&self, script: &str) -> PathBuf {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let path = self.root.path().join("npm");
|
||||
fs::write(&path, format!("#!/bin/sh\nset -eu\n{script}\n")).unwrap();
|
||||
fs::set_permissions(&path, fs::Permissions::from_mode(0o755)).unwrap();
|
||||
path
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn requires_the_selected_install_and_its_exact_package_entry() {
|
||||
let f = Fixture::new();
|
||||
assert_eq!(f.version().as_deref(), Some("2.1.9"));
|
||||
let other = f.root.path().join("other");
|
||||
fs::write(&other, "").unwrap();
|
||||
assert_eq!(f.install.version(&other, PKG, "claude").unwrap(), None);
|
||||
f.manifest("other-package", "2.1.9");
|
||||
assert_eq!(f.version(), None);
|
||||
f.manifest(PKG, "2.1.9");
|
||||
fs::remove_file(&f.install.link).unwrap();
|
||||
#[cfg(unix)]
|
||||
std::os::unix::fs::symlink(&other, &f.install.link).unwrap();
|
||||
#[cfg(windows)]
|
||||
fs::write(&f.install.link, r#"@"%dp0%\other""#).unwrap();
|
||||
assert_eq!(f.version(), None);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
const NPM: &str = r#"case "$1" in
|
||||
prefix) pwd -P ;;
|
||||
view) cat latest ;;
|
||||
install)
|
||||
test "$2" = "-g" && test "$3" = "--prefix" && test "$4" = "$(pwd -P)"
|
||||
test "$7" = "@anthropic-ai/[email protected]"
|
||||
cp updated.json "$4/lib/node_modules/@anthropic-ai/claude-code/package.json"
|
||||
touch installed ;;
|
||||
*) exit 2 ;;
|
||||
esac"#;
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn installs_only_the_confirmed_offer_and_rechecks_ownership() {
|
||||
use AgentCliUpdateResult::*;
|
||||
let f = Fixture::new();
|
||||
let npm = f.npm(NPM);
|
||||
let cancel = CancellationToken::new();
|
||||
let run =
|
||||
|offer: Option<&AgentCliOffer>| maintain(&npm, &f.install.link, "claude", PKG, offer, &cancel).unwrap();
|
||||
let latest = f.root.path().join("latest");
|
||||
fs::write(&latest, r#""2.1.12""#).unwrap();
|
||||
let Available(offer) = run(None) else { panic!("expected an offer") };
|
||||
for different in [
|
||||
AgentCliOffer { prefix: PathBuf::from("/other"), ..offer.clone() },
|
||||
AgentCliOffer { current: "2.0.0".into(), ..offer.clone() },
|
||||
] {
|
||||
assert_eq!(run(Some(&different)), Available(offer.clone()));
|
||||
}
|
||||
fs::write(&latest, r#""2.2.0""#).unwrap();
|
||||
assert!(matches!(run(Some(&offer)), Available(new) if new.latest == "2.2.0"));
|
||||
fs::write(&latest, r#""2.0.0""#).unwrap();
|
||||
assert!(matches!(run(Some(&offer)), Current { .. }));
|
||||
fs::write(&latest, r#""2.2.0-beta.1""#).unwrap();
|
||||
assert!(matches!(run(Some(&offer)), Channel { .. }));
|
||||
fs::write(&latest, r#""2.1.12""#).unwrap();
|
||||
f.manifest("other-package", "2.1.9");
|
||||
assert_eq!(run(Some(&offer)), Unmanaged);
|
||||
assert!(!f.root.path().join("installed").exists());
|
||||
f.manifest(PKG, "2.1.12");
|
||||
fs::copy(f.install.folder.join("package.json"), f.root.path().join("updated.json")).unwrap();
|
||||
f.manifest(PKG, "2.1.9");
|
||||
assert_eq!(run(Some(&offer)), Updated { current: "2.1.12".into() });
|
||||
assert!(f.root.path().join("installed").exists());
|
||||
assert_eq!(run(None), Current { current: "2.1.12".into() });
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn permission_failure_never_starts_an_install() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let f = Fixture::new();
|
||||
let npm = f.npm(NPM);
|
||||
fs::write(f.root.path().join("latest"), r#""2.1.12""#).unwrap();
|
||||
let run = |offer: Option<&AgentCliOffer>| {
|
||||
maintain(&npm, &f.install.link, "claude", PKG, offer, &CancellationToken::new()).unwrap()
|
||||
};
|
||||
let AgentCliUpdateResult::Available(offer) = run(None) else { panic!("expected an offer") };
|
||||
fs::set_permissions(&f.install.folder, fs::Permissions::from_mode(0o555)).unwrap();
|
||||
// root can write even when no mode bit grants write permission.
|
||||
if tempfile::tempfile_in(&f.install.folder).is_err() {
|
||||
assert_eq!(run(Some(&offer)), AgentCliUpdateResult::Permission(offer));
|
||||
}
|
||||
fs::set_permissions(&f.install.folder, fs::Permissions::from_mode(0o755)).unwrap();
|
||||
assert!(!f.root.path().join("installed").exists());
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn cancellation_stops_a_running_npm_process() {
|
||||
use std::time::{Duration, Instant};
|
||||
let f = Fixture::new();
|
||||
let npm = f.npm(
|
||||
r#"case "$1" in
|
||||
prefix) pwd -P ;;
|
||||
view) echo '"2.1.12"' ;;
|
||||
install) touch started; exec sleep 30 ;;
|
||||
esac"#,
|
||||
);
|
||||
let cancel = CancellationToken::new();
|
||||
let AgentCliUpdateResult::Available(offer) =
|
||||
maintain(&npm, &f.install.link, "claude", PKG, None, &cancel).unwrap()
|
||||
else {
|
||||
panic!("expected an offer")
|
||||
};
|
||||
let started = f.root.path().join("started");
|
||||
std::thread::scope(|s| {
|
||||
let op = s.spawn(|| maintain(&npm, &f.install.link, "claude", PKG, Some(&offer), &cancel));
|
||||
let deadline = Instant::now() + Duration::from_secs(5);
|
||||
while !started.exists() && Instant::now() < deadline {
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
}
|
||||
cancel.cancel();
|
||||
assert!(started.exists());
|
||||
assert_eq!(op.join().unwrap().unwrap_err().kind, ErrorKind::Cancelled);
|
||||
});
|
||||
assert_eq!(f.version().as_deref(), Some("2.1.9"));
|
||||
}
|
||||
}
|
||||
@@ -10,7 +10,6 @@
|
||||
mod acp;
|
||||
mod async_questions;
|
||||
mod catalogs;
|
||||
mod cli_update;
|
||||
mod config;
|
||||
mod conversation;
|
||||
mod elicitation;
|
||||
@@ -23,12 +22,11 @@ mod provider;
|
||||
pub mod registry;
|
||||
pub mod security;
|
||||
mod shell;
|
||||
pub mod skills;
|
||||
mod skills;
|
||||
mod timeline;
|
||||
mod worktree;
|
||||
|
||||
pub use catalogs::AgentCatalogs;
|
||||
pub use cli_update::{AgentCliOffer, AgentCliUpdateResult};
|
||||
pub use external::ExternalSession;
|
||||
pub use model::*;
|
||||
|
||||
@@ -131,19 +129,6 @@ pub type McpServersFn = dyn Fn() -> Vec<McpServer> + Send + Sync;
|
||||
/// Returns the executable of the running built-in MCP server, if any.
|
||||
pub type McpExecutableFn = dyn Fn() -> Option<PathBuf> + Send + Sync;
|
||||
|
||||
/// The `[agents.skills.<name>]` policies a session resolves against: the user's (global
|
||||
/// `settings.toml`), the workspace's (`.openidea/settings.toml`), and whether the workspace
|
||||
/// is trusted (an untrusted one can only turn skills off).
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct SkillsPolicy {
|
||||
pub user: BTreeMap<String, AgentSkillPolicy>,
|
||||
pub workspace: BTreeMap<String, AgentSkillPolicy>,
|
||||
pub workspace_trusted: bool,
|
||||
}
|
||||
|
||||
/// Returns the skill policies for this project.
|
||||
pub type SkillsPolicyFn = dyn Fn() -> SkillsPolicy + Send + Sync;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
||||
struct CopilotBinaryKey {
|
||||
command: String,
|
||||
@@ -156,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>>>,
|
||||
@@ -169,7 +154,6 @@ struct Shared {
|
||||
idle_release_ms: AtomicU64,
|
||||
mcp_servers_hook: RwLock<Option<Arc<McpServersFn>>>,
|
||||
mcp_executable_hook: RwLock<Option<Arc<McpExecutableFn>>>,
|
||||
skills_policy_hook: RwLock<Option<Arc<SkillsPolicyFn>>>,
|
||||
/// Monotonic id for [`AgentEvent::Attention`] episodes.
|
||||
attention_seq: AtomicU64,
|
||||
}
|
||||
@@ -229,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.
|
||||
@@ -542,8 +524,6 @@ struct Task {
|
||||
idle_epoch: AtomicU64,
|
||||
/// Turned on when per-session MCP overrides changed while a turn was busy; dropped once idle.
|
||||
mcp_reload_pending: AtomicBool,
|
||||
/// Turned on when per-session skill overrides changed while a turn was busy; dropped once idle.
|
||||
skills_reload_pending: AtomicBool,
|
||||
/// Settings already sent this session (`(option, value)`), so a refusal is not retried.
|
||||
config_sent: Mutex<HashSet<(String, String)>>,
|
||||
dirty: Mutex<BTreeSet<(Session, usize)>>,
|
||||
@@ -581,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,
|
||||
@@ -591,7 +571,6 @@ impl AgentManager {
|
||||
idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),
|
||||
mcp_servers_hook: RwLock::new(None),
|
||||
mcp_executable_hook: RwLock::new(None),
|
||||
skills_policy_hook: RwLock::new(None),
|
||||
attention_seq: AtomicU64::new(0),
|
||||
});
|
||||
shared.paths.catalogs.subscribe(&shared);
|
||||
@@ -625,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);
|
||||
@@ -741,15 +710,10 @@ impl AgentManager {
|
||||
*self.shared.mcp_executable_hook.write() = Some(Arc::from(hook));
|
||||
}
|
||||
|
||||
/// Provides the user and workspace skill policies and the workspace's trust.
|
||||
pub fn set_skills_policy_hook(&self, hook: Box<SkillsPolicyFn>) {
|
||||
*self.shared.skills_policy_hook.write() = Some(Arc::from(hook));
|
||||
}
|
||||
|
||||
/// The slash commands to complete for `provider`, in `task`'s directory or (without one)
|
||||
/// in the project: what the agent offered last time there, unadvertised builtins,
|
||||
/// for Claude Code the skills and custom commands on disk it has not listed (for
|
||||
/// Hermes, its profile's skills), and the skills hub's active skills for every agent.
|
||||
/// and, for Claude Code, skills and custom commands on disk it has not listed (for Hermes,
|
||||
/// its profile's skills).
|
||||
pub async fn commands(&self, provider: &str, task: Option<&str>) -> IdeResult<Vec<AgentCommand>> {
|
||||
let (provider, offered, cwd) = match task {
|
||||
Some(id) => {
|
||||
@@ -792,44 +756,11 @@ impl AgentManager {
|
||||
.await?;
|
||||
return Ok(skills::merge(offered, found));
|
||||
}
|
||||
if provider == "claude" || provider == "claude-acp" {
|
||||
let claude_cwd = cwd.clone();
|
||||
let found = blocking(move || Ok(skills::discover(&claude_cwd, home.as_deref()))).await?;
|
||||
offered = skills::merge(offered, found);
|
||||
if provider != "claude" && provider != "claude-acp" {
|
||||
return Ok(offered);
|
||||
}
|
||||
// The hub's active skills complete on every agent; its `off` ones drop out here,
|
||||
// which is all the enforcement an ACP agent gets.
|
||||
let holder = self.task_for_commands(&provider, task);
|
||||
let states = match holder {
|
||||
Some(holder) => holder.skill_states().await,
|
||||
None => {
|
||||
let (policy, root) = {
|
||||
let shared = &self.shared;
|
||||
let policy = shared.skills_policy_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
|
||||
(policy, shared.paths.project_root.clone())
|
||||
};
|
||||
let home = self.shared.paths.home_dir.clone();
|
||||
blocking(move || {
|
||||
Ok(skills::resolve(
|
||||
skills::discover_skills(&root, home.as_deref()),
|
||||
None,
|
||||
&policy.workspace,
|
||||
&policy.user,
|
||||
policy.workspace_trusted,
|
||||
))
|
||||
})
|
||||
.await
|
||||
.unwrap_or_default()
|
||||
}
|
||||
};
|
||||
Ok(skills::menu_commands(offered, &states))
|
||||
}
|
||||
|
||||
/// The task to resolve skills for, when the commands are for one and its provider matches.
|
||||
fn task_for_commands(&self, provider: &str, task: Option<&str>) -> Option<Arc<Task>> {
|
||||
let task = self.task(task?).ok()?;
|
||||
let matches = task.state.lock().task.provider == provider;
|
||||
matches.then_some(task)
|
||||
let found = blocking(move || Ok(skills::discover(&cwd, home.as_deref()))).await?;
|
||||
Ok(skills::merge(offered, found))
|
||||
}
|
||||
|
||||
fn task(&self, id: &str) -> IdeResult<Arc<Task>> {
|
||||
@@ -913,7 +844,6 @@ impl AgentManager {
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
skill_overrides: BTreeMap::new(),
|
||||
stats: Box::default(),
|
||||
};
|
||||
let file = TaskFile {
|
||||
@@ -1032,7 +962,6 @@ impl AgentManager {
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: req.mcp_overrides,
|
||||
skill_overrides: req.skill_overrides,
|
||||
stats: Box::default(),
|
||||
};
|
||||
let file = TaskFile {
|
||||
@@ -1376,14 +1305,13 @@ impl AgentManager {
|
||||
(s.task.cwd.0.clone(), s.task.provider.clone(), s.task.mcp_overrides.clone())
|
||||
};
|
||||
let mcp_servers = source.shared.mcp_servers_for_session(&provider_id, &live.init, &mcp_overrides);
|
||||
let skills_delivery = source.stage_skills(stage_key(live.driver), &cwd).await;
|
||||
let cwd_s = dunce::canonicalize(&cwd).unwrap_or(cwd).to_string_lossy().into_owned();
|
||||
let reply: Value = live
|
||||
.peer
|
||||
.request(
|
||||
"session/fork",
|
||||
{
|
||||
let mut params = session_params(&cwd_s, &mcp_servers, skills_delivery.as_ref());
|
||||
let mut params = session_params(&cwd_s, &mcp_servers);
|
||||
params["sessionId"] = json!(live.session);
|
||||
params
|
||||
},
|
||||
@@ -1629,18 +1557,6 @@ impl AgentManager {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn context_usage(&self, id: &str) -> IdeResult<AgentContextUsage> {
|
||||
let task = self.task(id)?;
|
||||
let live = task.live.lock().clone().ok_or_else(|| IdeError::unavailable("the agent session is offline"))?;
|
||||
if !live.capabilities.context_usage {
|
||||
return Err(IdeError::unavailable("this agent does not report context details"));
|
||||
}
|
||||
live.peer
|
||||
.request("_openidea/context_usage", json!({ "sessionId": live.session }), None)
|
||||
.await
|
||||
.map_err(|error| IdeError::internal(task.describe(error)))
|
||||
}
|
||||
|
||||
/// Stops background task `background` of task `id`.
|
||||
pub async fn stop_background(&self, id: &str, background: &str) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
@@ -1784,7 +1700,6 @@ impl AgentManager {
|
||||
*task.deleted.lock() = true;
|
||||
let _ = std::fs::remove_file(self.shared.paths.store_dir.join(format!("{id}.json")));
|
||||
let _ = std::fs::remove_dir_all(task.turn_dir());
|
||||
skills::remove_farm(&self.shared.paths.store_dir, id);
|
||||
let saved = task.state.lock().saved.clone();
|
||||
if let Some(saved) = saved
|
||||
&& !self.tasks.read().values().any(|t| t.state.lock().saved.as_ref() == Some(&saved))
|
||||
@@ -2046,38 +1961,6 @@ impl AgentManager {
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Sets the session's skill modes; like MCP overrides, a change reaches the agent when
|
||||
/// its idle session is recycled and the next turn starts fresh.
|
||||
pub fn set_skill_overrides(&self, id: &str, overrides: BTreeMap<String, AgentSkillMode>) -> IdeResult<AgentTask> {
|
||||
let task = self.task(id)?;
|
||||
let cleaned: BTreeMap<String, AgentSkillMode> = overrides
|
||||
.into_iter()
|
||||
.filter_map(|(k, v)| (!k.trim().is_empty()).then(|| (k.trim().to_owned(), v)))
|
||||
.collect();
|
||||
let (changed, busy, has_bg, out) = {
|
||||
let mut s = task.state.lock();
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
let changed = s.task.skill_overrides != cleaned;
|
||||
if changed {
|
||||
s.task.skill_overrides = cleaned;
|
||||
s.task.updated_ms = now_ms();
|
||||
}
|
||||
(changed, s.busy, !s.background_tasks.is_empty(), s.task.clone())
|
||||
};
|
||||
if changed {
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
if busy || has_bg || !task.permissions.lock().is_empty() {
|
||||
task.skills_reload_pending.store(true, Ordering::Release);
|
||||
} else {
|
||||
task.recycle_resumable_session();
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Recycles idle resumable live sessions (or schedules reload after the running turn) when
|
||||
/// global, workspace, or built-in IDE MCP server settings change.
|
||||
pub fn notify_mcp_servers_changed(&self) {
|
||||
@@ -2105,60 +1988,11 @@ 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;
|
||||
}
|
||||
}
|
||||
|
||||
impl Task {
|
||||
/// The skills offered in this project: every discovery resolved against the policies
|
||||
/// and the task's overrides.
|
||||
async fn skill_states(&self) -> Vec<AgentSkillState> {
|
||||
let (policy, overrides, home, root) = {
|
||||
let shared = &self.shared;
|
||||
let policy = shared.skills_policy_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
|
||||
let overrides = self.state.lock().task.skill_overrides.clone();
|
||||
(policy, overrides, shared.paths.home_dir.clone(), shared.paths.project_root.clone())
|
||||
};
|
||||
blocking(move || {
|
||||
Ok(skills::resolve(
|
||||
skills::discover_skills(&root, home.as_deref()),
|
||||
Some(&overrides),
|
||||
&policy.workspace,
|
||||
&policy.user,
|
||||
policy.workspace_trusted,
|
||||
))
|
||||
})
|
||||
.await
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Stages the session's skills into the task's farm and reports what its CLI takes.
|
||||
/// Nothing staged for an ACP agent (its `/` menu is filtered instead), and a failed
|
||||
/// stage (locked files, full disk) runs the session without the farm.
|
||||
async fn stage_skills(&self, provider: &str, cwd: &Path) -> Option<skills::Delivery> {
|
||||
let states = self.skill_states().await;
|
||||
let (farm, home, out_cwd) = {
|
||||
(
|
||||
skills::farm_dir(&self.shared.paths.store_dir, &self.id),
|
||||
self.shared.paths.home_dir.clone(),
|
||||
cwd.to_path_buf(),
|
||||
)
|
||||
};
|
||||
let provider = provider.to_owned();
|
||||
match blocking(move || {
|
||||
skills::stage(&farm, &provider, &states, &out_cwd, home.as_deref())
|
||||
.map_err(|e| IdeError::internal(e.to_string()))
|
||||
})
|
||||
.await
|
||||
{
|
||||
Ok(delivery) => Some(delivery),
|
||||
Err(e) => {
|
||||
tracing::warn!("agent task {}: staging its skills failed: {e}", self.id);
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn restore(file: TaskFile, shared: Arc<Shared>) -> Arc<Self> {
|
||||
let mut task = file.task;
|
||||
config::add_client_options(&task.provider, &mut task.config);
|
||||
@@ -2215,7 +2049,6 @@ impl Task {
|
||||
turns: AtomicU64::new(0),
|
||||
idle_epoch: AtomicU64::new(0),
|
||||
mcp_reload_pending: AtomicBool::new(false),
|
||||
skills_reload_pending: AtomicBool::new(false),
|
||||
config_sent: Mutex::new(HashSet::new()),
|
||||
dirty: Mutex::new(BTreeSet::new()),
|
||||
streamed: Mutex::new(HashMap::new()),
|
||||
@@ -2507,8 +2340,7 @@ impl Task {
|
||||
if stop != "cancelled" {
|
||||
self.emit_attention(AgentAttentionReason::Finished);
|
||||
}
|
||||
if (self.mcp_reload_pending.swap(false, Ordering::AcqRel)
|
||||
|| self.skills_reload_pending.swap(false, Ordering::AcqRel))
|
||||
if self.mcp_reload_pending.swap(false, Ordering::AcqRel)
|
||||
&& self.state.lock().background_tasks.is_empty()
|
||||
{
|
||||
self.recycle_resumable_session();
|
||||
@@ -3026,7 +2858,6 @@ impl Task {
|
||||
let (capabilities, embedded) = capabilities_of(&init);
|
||||
let mcp_overrides = self.state.lock().task.mcp_overrides.clone();
|
||||
let mcp_servers = self.shared.mcp_servers_for_session(provider_id, &init, &mcp_overrides);
|
||||
let skills_delivery = self.stage_skills(stage_key(spec.driver), cwd).await;
|
||||
// Agents that compare canonical paths fail in a symlinked directory (macOS `/tmp`).
|
||||
let cwd_s = dunce::canonicalize(cwd).unwrap_or_else(|_| cwd.to_path_buf()).to_string_lossy().into_owned();
|
||||
|
||||
@@ -3041,7 +2872,7 @@ impl Task {
|
||||
}
|
||||
if let (Some(id), true, false) = (saved, can_load, start_fresh) {
|
||||
self.replaying.store(true, Ordering::Release);
|
||||
let mut params = session_params(&cwd_s, &mcp_servers, skills_delivery.as_ref());
|
||||
let mut params = session_params(&cwd_s, &mcp_servers);
|
||||
params["sessionId"] = json!(&id);
|
||||
let loaded = self.request_with_auth(&peer, &init, &mut tried_auth, "session/load", params).await;
|
||||
tokio::time::sleep(REPLAY_GRACE).await;
|
||||
@@ -3081,7 +2912,7 @@ impl Task {
|
||||
let (session_id, result) = match session {
|
||||
Some(s) => s,
|
||||
None => {
|
||||
let params = session_params(&cwd_s, &mcp_servers, skills_delivery.as_ref());
|
||||
let params = session_params(&cwd_s, &mcp_servers);
|
||||
let v = self.request_with_auth(&peer, &init, &mut tried_auth, "session/new", params).await.map_err(
|
||||
|e| match self.sign_in_error(&e, Some(&sign_in_message)) {
|
||||
Some(msg) => SessionOpenError { message: msg, allow_acp_fallback: false },
|
||||
@@ -4036,7 +3867,6 @@ fn capabilities_of(init: &acp::Negotiated) -> (AgentCapabilities, bool) {
|
||||
rollback: meta("/openidea/rollback"),
|
||||
steer: steer_method(init).is_some(),
|
||||
background_tasks: meta("/openidea/backgroundTasks"),
|
||||
context_usage: meta("/openidea/contextUsage"),
|
||||
};
|
||||
(capabilities, init.prompt("embeddedContext"))
|
||||
}
|
||||
@@ -4057,34 +3887,13 @@ struct McpForSession {
|
||||
off: Vec<String>,
|
||||
}
|
||||
|
||||
/// The driver a session's staged skills are staged for (`skills::stage` matches on it):
|
||||
/// the native CLIs take the farm, everything else (an ACP agent) gets the `/` menu filter.
|
||||
fn stage_key(driver: provider::Driver) -> &'static str {
|
||||
match driver {
|
||||
provider::Driver::Claude => "claude",
|
||||
provider::Driver::Codex => "codex",
|
||||
provider::Driver::Copilot => "copilot",
|
||||
provider::Driver::Acp => "acp",
|
||||
}
|
||||
}
|
||||
|
||||
/// The session parameters `session/new`, `session/load` and `session/fork` share: the MCP
|
||||
/// servers, and the ones off for this session, so an agent that also loads its own
|
||||
/// configuration (Claude Code) can keep a same-named server of it off too — plus the
|
||||
/// session's staged skills for the drivers that take them.
|
||||
fn session_params(cwd: &str, mcp: &McpForSession, skills: Option<&skills::Delivery>) -> Value {
|
||||
/// configuration (Claude Code) can keep a same-named server of it off too.
|
||||
fn session_params(cwd: &str, mcp: &McpForSession) -> Value {
|
||||
let mut params = json!({ "cwd": cwd, "mcpServers": mcp.servers });
|
||||
let mut meta = json!({});
|
||||
if !mcp.off.is_empty() {
|
||||
meta["mcpServersOff"] = json!(mcp.off);
|
||||
}
|
||||
if let Some(skills) = skills
|
||||
&& let Ok(v) = serde_json::to_value(skills)
|
||||
{
|
||||
meta["skills"] = v;
|
||||
}
|
||||
if !meta.is_null() && meta.as_object().is_some_and(|m| !m.is_empty()) {
|
||||
params["_meta"] = json!({ "openidea": meta });
|
||||
params["_meta"] = json!({ "openidea": { "mcpServersOff": mcp.off } });
|
||||
}
|
||||
params
|
||||
}
|
||||
|
||||
@@ -45,8 +45,6 @@ pub struct AgentCapabilities {
|
||||
pub steer: bool,
|
||||
/// It reports its background tasks and stops them one by one.
|
||||
pub background_tasks: bool,
|
||||
/// The connected agent can report a breakdown of its context window.
|
||||
pub context_usage: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
@@ -110,9 +108,6 @@ pub struct AgentTask {
|
||||
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`), including `"openidea"`.
|
||||
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
|
||||
pub mcp_overrides: BTreeMap<String, bool>,
|
||||
/// Per-session skill modes (`skill name` -> mode), on top of the settings' policies.
|
||||
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
|
||||
pub skill_overrides: BTreeMap<String, AgentSkillMode>,
|
||||
/// Token counts of the last turn and context compressions, when the agent reports them.
|
||||
// Boxed so that `AgentEvent::Task` stays within clippy's `large_enum_variant` bound on Windows.
|
||||
#[serde(default)]
|
||||
@@ -280,24 +275,6 @@ pub struct AgentUsage {
|
||||
pub cost: Option<Box<AgentCost>>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentContextUsage {
|
||||
pub categories: Vec<AgentContextCategory>,
|
||||
pub total_tokens: u32,
|
||||
pub max_tokens: u32,
|
||||
pub model: String,
|
||||
pub is_auto_compact_enabled: Option<bool>,
|
||||
pub auto_compact_threshold: Option<u32>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
pub struct AgentContextCategory {
|
||||
pub name: String,
|
||||
pub tokens: u32,
|
||||
pub kind: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentCost {
|
||||
@@ -617,9 +594,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.
|
||||
@@ -690,9 +664,6 @@ pub struct NewAgentTask {
|
||||
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`).
|
||||
#[serde(default)]
|
||||
pub mcp_overrides: BTreeMap<String, bool>,
|
||||
/// Per-session skill modes (`skill name` -> mode).
|
||||
#[serde(default)]
|
||||
pub skill_overrides: BTreeMap<String, AgentSkillMode>,
|
||||
/// Creates the task without sending `prompt` (it only names the task): the composer's
|
||||
/// `!` command runs in it first.
|
||||
#[serde(default)]
|
||||
@@ -885,84 +856,6 @@ fn default_true() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
pub use ide_core::settings::{AgentSkillMode, AgentSkillPolicy};
|
||||
|
||||
/// Which CLI's own folders a skill was discovered in (Settings › Agents › Skills groups by it).
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum AgentSkillSource {
|
||||
/// The project's `.agents/skills` and `.openidea/skills`.
|
||||
#[default]
|
||||
Workspace,
|
||||
/// The user's `~/.agents/skills` (what `npx skills add` fills).
|
||||
User,
|
||||
/// The project's `.claude/skills`.
|
||||
ClaudeWorkspace,
|
||||
/// `~/.claude/skills`.
|
||||
ClaudeUser,
|
||||
/// The project's `.github/skills` (Copilot's repository skills).
|
||||
GithubWorkspace,
|
||||
/// `~/.copilot/skills` and `~/.copilot/installed-plugins/*`.
|
||||
CopilotUser,
|
||||
/// The project's `.codex/skills`.
|
||||
CodexWorkspace,
|
||||
/// `~/.codex/skills`.
|
||||
CodexUser,
|
||||
/// The project's `.cursor/skills`.
|
||||
CursorWorkspace,
|
||||
/// `~/.cursor/skills`.
|
||||
CursorUser,
|
||||
}
|
||||
|
||||
impl AgentSkillSource {
|
||||
/// Whether skills of this source are only read, never delivered by OpenIDEA: the CLI
|
||||
/// discovers them itself, so "off" holds only where the CLI supports a native disable.
|
||||
pub fn discovered(&self) -> bool {
|
||||
!matches!(self, Self::Workspace | Self::User)
|
||||
}
|
||||
}
|
||||
|
||||
/// One discovered skill: a folder with a `SKILL.md`.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentSkill {
|
||||
/// The frontmatter `name`, else the folder's name.
|
||||
pub name: String,
|
||||
pub description: String,
|
||||
/// Canonical folder holding `SKILL.md` (symlinks resolved, so duplicates collapse).
|
||||
pub path: IpcPath,
|
||||
pub source: AgentSkillSource,
|
||||
/// The `SKILL.md` passes validation (`name` matches its folder, `description` present).
|
||||
pub valid: bool,
|
||||
/// What validation found (`name` mismatch, missing or over-long description…).
|
||||
pub warnings: Vec<String>,
|
||||
}
|
||||
|
||||
/// A skill as Settings › Agents › Skills shows it: discovery plus the effective mode and
|
||||
/// which layer decided it.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentSkillState {
|
||||
pub skill: AgentSkill,
|
||||
pub mode: AgentSkillMode,
|
||||
/// What set `mode`: a session override, the workspace, the user's settings, workspace
|
||||
/// trust, or nothing (the default `auto`).
|
||||
pub origin: AgentSkillOrigin,
|
||||
}
|
||||
|
||||
/// Which layer decided a skill's [`AgentSkillState::mode`].
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum AgentSkillOrigin {
|
||||
#[default]
|
||||
None,
|
||||
Session,
|
||||
Workspace,
|
||||
User,
|
||||
/// An untrusted workspace's skills and policies may only turn skills off.
|
||||
Trust,
|
||||
}
|
||||
|
||||
/// An external MCP configuration file discovered on disk (user CLI config or workspace file).
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
|
||||
@@ -172,10 +172,6 @@ struct Session {
|
||||
mcp_config: Option<tempfile::TempPath>,
|
||||
/// MCP servers switched off for this session (`--disallowedTools`), its own config's too.
|
||||
mcp_off: Vec<String>,
|
||||
/// The staged skills folder passed as `--add-dir` (its `.claude/skills` holds the copies).
|
||||
skills_add_dir: Option<PathBuf>,
|
||||
/// The staged skills' `--settings` JSON (`skillOverrides` for the native ones too).
|
||||
skills_settings: Option<String>,
|
||||
shim: Weak<Shim>,
|
||||
st: Mutex<State>,
|
||||
/// Serializes (re)starting the process.
|
||||
@@ -360,13 +356,10 @@ impl Shim {
|
||||
None
|
||||
}
|
||||
});
|
||||
let skills = params.pointer("/_meta/openidea/skills");
|
||||
let session = Arc::new(Session {
|
||||
id: id.to_owned(),
|
||||
mcp_config,
|
||||
mcp_off,
|
||||
skills_add_dir: skills.and_then(|s| s.get("claudeAddDir")).and_then(Value::as_str).map(PathBuf::from),
|
||||
skills_settings: skills.and_then(|s| s.get("claudeSettings")).and_then(Value::as_str).map(str::to_owned),
|
||||
shim: Arc::downgrade(self),
|
||||
st: Mutex::new(State {
|
||||
proc: None,
|
||||
@@ -414,7 +407,7 @@ impl Shim {
|
||||
"promptCapabilities": { "image": true, "embeddedContext": true },
|
||||
"sessionCapabilities": { "fork": {} },
|
||||
"mcpCapabilities": { "stdio": true, "http": true, "sse": true },
|
||||
"_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true, "contextUsage": true } },
|
||||
"_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true } },
|
||||
},
|
||||
"agentInfo": { "name": "claude", "title": "Claude Code", "version": self.version() },
|
||||
"authMethods": [],
|
||||
@@ -499,11 +492,6 @@ impl Shim {
|
||||
session.steer(params.get("prompt").cloned().unwrap_or_default()).map_err(invalid)?;
|
||||
Ok(json!({}))
|
||||
}
|
||||
"_openidea/context_usage" => {
|
||||
let session = self.session(¶ms)?;
|
||||
let proc = session.st.lock().proc.clone().ok_or_else(|| internal("Claude Code is not running"))?;
|
||||
rt.block_on(proc.control(json!({ "subtype": "get_context_usage" }))).map_err(internal)
|
||||
}
|
||||
"_openidea/stop_task" => {
|
||||
let session = self.session(¶ms)?;
|
||||
let task = params.get("taskId").and_then(Value::as_str).ok_or_else(|| invalid("no taskId"))?;
|
||||
@@ -680,14 +668,6 @@ impl Session {
|
||||
if !self.mcp_off.is_empty() {
|
||||
args.extend(["--disallowedTools".to_owned(), self.mcp_off.join(",")]);
|
||||
}
|
||||
// The staged skills: `.claude/skills` of the added directory is discovered like the
|
||||
// project's own, and the settings hold the modes of the skills it sees natively too.
|
||||
if let Some(dir) = &self.skills_add_dir {
|
||||
args.extend(["--add-dir".to_owned(), dir.to_string_lossy().into_owned()]);
|
||||
}
|
||||
if let Some(settings) = &self.skills_settings {
|
||||
args.extend(["--settings".to_owned(), settings.clone()]);
|
||||
}
|
||||
args.extend(start.args());
|
||||
let launch =
|
||||
Launch { program: shim.config.program.clone(), args, cwd: self.cwd.clone(), env: shim.config.env.clone() };
|
||||
|
||||
@@ -334,31 +334,6 @@ fn str_param<'a>(params: &'a Value, key: &str) -> Result<&'a str, ResponseError>
|
||||
params.get(key).and_then(Value::as_str).ok_or_else(|| invalid(format!("missing {key}")))
|
||||
}
|
||||
|
||||
/// Fills a `thread/start`/`thread/resume`/`thread/fork` request's `config` with the session's
|
||||
/// MCP servers and its staged skills: the off ones, by path (`skills.config` entries with
|
||||
/// `enabled = false`, which the CLI honors for the copies it discovers natively too).
|
||||
fn apply_thread_config(params: &Value, request: &mut Value) {
|
||||
let mut config = translate::mcp_config(params).unwrap_or_else(|| json!({}));
|
||||
let off: Vec<Value> = params
|
||||
.pointer("/_meta/openidea/skills/codexOff")
|
||||
.and_then(Value::as_array)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|entry| {
|
||||
let path = entry.get(1)?.as_str()?;
|
||||
Some(json!({ "path": path, "enabled": false }))
|
||||
})
|
||||
.collect();
|
||||
if !off.is_empty()
|
||||
&& let Some(map) = config.as_object_mut()
|
||||
{
|
||||
map.insert("skills".into(), json!({ "config": off }));
|
||||
}
|
||||
if !config.as_object().is_some_and(|m| m.is_empty()) {
|
||||
request["config"] = config;
|
||||
}
|
||||
}
|
||||
|
||||
impl CodexShim {
|
||||
fn codex(&self) -> &Peer {
|
||||
self.codex.get().expect("attached before any message")
|
||||
@@ -439,31 +414,6 @@ impl CodexShim {
|
||||
}
|
||||
}
|
||||
|
||||
/// Hands the session's staged skills to the app-server: the farm's `codex` tree joins
|
||||
/// its discovery roots. Best-effort: a CLI version without `skills/extraRoots/set`
|
||||
/// (the method arrived later than some pinned installs) runs without the farm, as
|
||||
/// before.
|
||||
async fn apply_skill_roots(&self, session: &str, params: &Value) {
|
||||
let roots = params
|
||||
.pointer("/_meta/openidea/skills/codexExtraRoots")
|
||||
.and_then(Value::as_array)
|
||||
.map(|a| a.iter().filter_map(Value::as_str).collect::<Vec<_>>())
|
||||
.unwrap_or_default();
|
||||
if roots.is_empty() {
|
||||
return;
|
||||
}
|
||||
let set = tokio::time::timeout(
|
||||
Duration::from_secs(5),
|
||||
self.call("skills/extraRoots/set", json!({ "extraRoots": roots })),
|
||||
)
|
||||
.await;
|
||||
match set {
|
||||
Ok(Ok(_)) => {}
|
||||
Ok(Err(e)) => tracing::info!("codex session {session}: could not set the extra skill roots: {}", e.message),
|
||||
Err(e) => tracing::info!("codex session {session}: could not set the extra skill roots: {e}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Registers a thread codex opened for a session of its own; returns its `configOptions`.
|
||||
fn open_thread(&self, result: &Value, models: &[ModelInfo], settings: Option<Settings>) -> (String, Value) {
|
||||
let thread = result.get("thread").unwrap_or(&Value::Null);
|
||||
@@ -484,13 +434,14 @@ impl CodexShim {
|
||||
let models = self.models().await?;
|
||||
self.prepare_project_trust(params).await;
|
||||
let mut request = json!({ "cwd": params.get("cwd") });
|
||||
apply_thread_config(params, &mut request);
|
||||
if let Some(config) = translate::mcp_config(params) {
|
||||
request["config"] = config;
|
||||
}
|
||||
let result = self.call("thread/start", request).await?;
|
||||
let (id, options) = self.open_thread(&result, &models, None);
|
||||
if id.is_empty() {
|
||||
return Err(error(codes::INTERNAL_ERROR, "codex started no thread"));
|
||||
}
|
||||
self.apply_skill_roots(&id, params).await;
|
||||
self.publish_skills(&id).await;
|
||||
Ok(json!({ "sessionId": id, "configOptions": options }))
|
||||
}
|
||||
@@ -501,7 +452,9 @@ impl CodexShim {
|
||||
let models = self.models().await?;
|
||||
self.prepare_project_trust(params).await;
|
||||
let mut request = json!({ "threadId": id, "cwd": params.get("cwd") });
|
||||
apply_thread_config(params, &mut request);
|
||||
if let Some(config) = translate::mcp_config(params) {
|
||||
request["config"] = config;
|
||||
}
|
||||
let result = self.call("thread/resume", request).await?;
|
||||
let (_, options) = self.open_thread(&result, &models, None);
|
||||
let cwd = self.state.lock().threads.get(id).and_then(|t| t.cwd.clone());
|
||||
@@ -509,7 +462,6 @@ impl CodexShim {
|
||||
for update in translate::history(thread, cwd.as_deref()) {
|
||||
self.emit(id, update);
|
||||
}
|
||||
self.apply_skill_roots(id, params).await;
|
||||
self.publish_skills(id).await;
|
||||
Ok(json!({ "configOptions": options }))
|
||||
}
|
||||
@@ -520,7 +472,9 @@ impl CodexShim {
|
||||
self.prepare_project_trust(params).await;
|
||||
let settings = self.state.lock().threads.get(source).and_then(|t| t.settings.clone());
|
||||
let mut request = json!({ "threadId": source, "cwd": params.get("cwd") });
|
||||
apply_thread_config(params, &mut request);
|
||||
if let Some(config) = translate::mcp_config(params) {
|
||||
request["config"] = config;
|
||||
}
|
||||
if let Some(s) = &settings {
|
||||
request["model"] = json!(s.model_slug(&models));
|
||||
request["approvalPolicy"] = json!(s.mode.approval_policy());
|
||||
@@ -528,7 +482,6 @@ impl CodexShim {
|
||||
}
|
||||
let result = self.call("thread/fork", request).await?;
|
||||
let (id, options) = self.open_thread(&result, &models, settings);
|
||||
self.apply_skill_roots(&id, params).await;
|
||||
self.publish_skills(&id).await;
|
||||
Ok(json!({ "sessionId": id, "configOptions": options }))
|
||||
}
|
||||
|
||||
@@ -372,24 +372,6 @@ fn error(code: i64, message: impl Into<String>) -> ResponseError {
|
||||
ResponseError { code, message: message.into(), data: None }
|
||||
}
|
||||
|
||||
/// Adds the session's staged skills to a `session.create`/`session.resume` request:
|
||||
/// `skillDirectories` (the farm's `copilot` tree) and `disabledSkills` (the off and
|
||||
/// slash-only ones; Copilot invokes skills with the model only, so a slash-only skill has
|
||||
/// no other switch here).
|
||||
fn apply_skills(params: &Value, req: &mut Value) {
|
||||
let skills = params.pointer("/_meta/openidea/skills");
|
||||
if let Some(dirs) = skills.and_then(|s| s.get("copilotSkillDirectories")).and_then(Value::as_array)
|
||||
&& !dirs.is_empty()
|
||||
{
|
||||
req["skillDirectories"] = json!(dirs.iter().filter_map(Value::as_str).collect::<Vec<_>>());
|
||||
}
|
||||
if let Some(disabled) = skills.and_then(|s| s.get("copilotDisabledSkills")).and_then(Value::as_array)
|
||||
&& !disabled.is_empty()
|
||||
{
|
||||
req["disabledSkills"] = json!(disabled.iter().filter_map(Value::as_str).collect::<Vec<_>>());
|
||||
}
|
||||
}
|
||||
|
||||
fn invalid(message: impl Into<String>) -> ResponseError {
|
||||
error(codes::INVALID_PARAMS, message)
|
||||
}
|
||||
@@ -514,7 +496,6 @@ impl CopilotShim {
|
||||
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
|
||||
req["disabledMcpServers"] = disabled;
|
||||
}
|
||||
apply_skills(params, &mut req);
|
||||
|
||||
let created = self.call("session.create", req).await?;
|
||||
let session_id = created
|
||||
@@ -565,7 +546,6 @@ impl CopilotShim {
|
||||
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
|
||||
req["disabledMcpServers"] = disabled;
|
||||
}
|
||||
apply_skills(params, &mut req);
|
||||
|
||||
let resumed = self.call("session.resume", req).await?;
|
||||
if let Ok(current) = self.call("session.model.getCurrent", json!({ "sessionId": session_id })).await {
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -1,17 +1,11 @@
|
||||
//! Slash commands and skills on disk. Claude Code's own discovery (`.claude/skills` and
|
||||
//! `.claude/commands` of the working directory tree and `~/.claude`, and a Hermes profile's
|
||||
//! `skills`) for completion before (or without) a session, plus the multi-level skills hub
|
||||
//! of #3897: every CLI's skill folders discovered once, deduplicated by canonical path,
|
||||
//! resolved against the `[agents.skills.<name>]` policies of the global and workspace
|
||||
//! settings, and staged into a per-session folder the CLIs each receive their own way.
|
||||
//! Claude Code's slash commands on disk, for completion before (or without) a session:
|
||||
//! skills (`.claude/skills/<dir>/SKILL.md`) and custom commands (`.claude/commands/**/*.md`)
|
||||
//! of the working directory and every directory above it, then the user's `~/.claude`; and
|
||||
//! the skills of a Hermes profile (`<profile>/skills`).
|
||||
|
||||
use crate::{
|
||||
AgentCommand, AgentCommandSource, AgentSkill, AgentSkillMode, AgentSkillOrigin, AgentSkillPolicy, AgentSkillSource,
|
||||
AgentSkillState,
|
||||
};
|
||||
use ide_core::output_encoding::strip_ansi;
|
||||
use std::collections::{BTreeMap, HashSet};
|
||||
use std::path::{Path, PathBuf};
|
||||
use crate::{AgentCommand, AgentCommandSource};
|
||||
use std::collections::HashSet;
|
||||
use std::path::Path;
|
||||
|
||||
const MAX_DESCRIPTION: usize = 200;
|
||||
/// Command directories nest this deep at most (`a/b/c.md` → `a:b:c`).
|
||||
@@ -206,370 +200,6 @@ fn truncate(s: &str) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
// ─── The skills hub (#3897): discovery, policy, delivery ────────────────────────────
|
||||
|
||||
/// A skill's `name` must be this and lowercase letters, digits and hyphens only.
|
||||
fn valid_name(name: &str) -> bool {
|
||||
(1..=64).contains(&name.len()) && name.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-')
|
||||
}
|
||||
|
||||
/// A `SKILL.md`'s description is at most this many characters.
|
||||
const MAX_SKILL_DESCRIPTION: usize = 1024;
|
||||
|
||||
/// The workspace folders skills are discovered in, by the source they report.
|
||||
const WORKSPACE_ROOTS: &[(&str, AgentSkillSource)] = &[
|
||||
(".agents/skills", AgentSkillSource::Workspace),
|
||||
(".openidea/skills", AgentSkillSource::Workspace),
|
||||
(".claude/skills", AgentSkillSource::ClaudeWorkspace),
|
||||
(".github/skills", AgentSkillSource::GithubWorkspace),
|
||||
(".codex/skills", AgentSkillSource::CodexWorkspace),
|
||||
(".cursor/skills", AgentSkillSource::CursorWorkspace),
|
||||
];
|
||||
|
||||
/// The home folders skills are discovered in, by the source they report.
|
||||
const HOME_ROOTS: &[(&str, AgentSkillSource)] = &[
|
||||
(".agents/skills", AgentSkillSource::User),
|
||||
(".claude/skills", AgentSkillSource::ClaudeUser),
|
||||
(".copilot/skills", AgentSkillSource::CopilotUser),
|
||||
(".codex/skills", AgentSkillSource::CodexUser),
|
||||
(".cursor/skills", AgentSkillSource::CursorUser),
|
||||
];
|
||||
|
||||
/// Every skill found under `workspace` (a project, scanned even for a worktree task, whose
|
||||
/// checkout lacks untracked skills) and `home`, in source precedence order, symlinked
|
||||
/// duplicates collapsed by canonical path: the first of a path wins, and so does the first
|
||||
/// of a name (the higher source), so a session never sees one skill twice.
|
||||
pub fn discover_skills(workspace: &Path, home: Option<&Path>) -> Vec<AgentSkill> {
|
||||
let mut out: Vec<AgentSkill> = Vec::new();
|
||||
let mut seen_paths: HashSet<PathBuf> = HashSet::new();
|
||||
let mut seen_names: HashSet<String> = HashSet::new();
|
||||
let mut roots: Vec<(PathBuf, AgentSkillSource)> = Vec::new();
|
||||
roots.extend(WORKSPACE_ROOTS.iter().map(|(rel, source)| (workspace.join(rel), *source)));
|
||||
let mut plugin_roots = Vec::new();
|
||||
if let Some(home) = home {
|
||||
roots.extend(HOME_ROOTS.iter().map(|(rel, source)| (home.join(rel), *source)));
|
||||
// `copilot install` unpacks plugins under `installed-plugins/<plugin>/`, whose skills
|
||||
// sit in a `skills` folder (or directly in the plugin folder).
|
||||
let plugins = home.join(".copilot/installed-plugins");
|
||||
if let Ok(plugins) = plugins.read_dir() {
|
||||
for plugin in plugins.flatten() {
|
||||
if plugin.path().is_dir() {
|
||||
plugin_roots.push((plugin.path().join("skills"), AgentSkillSource::CopilotUser));
|
||||
plugin_roots.push((plugin.path(), AgentSkillSource::CopilotUser));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
roots.extend(plugin_roots);
|
||||
for (root, source) in roots {
|
||||
for skill in skills_of(&root, source) {
|
||||
let path = dunce::canonicalize(&skill.path.0).unwrap_or_else(|_| skill.path.0.clone());
|
||||
if !seen_paths.insert(path.clone()) || !seen_names.insert(skill.name.clone()) {
|
||||
continue;
|
||||
}
|
||||
out.push(AgentSkill { path: path.into(), ..skill });
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The skills of one root: `<name>/SKILL.md` folders, validated.
|
||||
fn skills_of(root: &Path, source: AgentSkillSource) -> Vec<AgentSkill> {
|
||||
let mut out: Vec<AgentSkill> = Vec::new();
|
||||
let Ok(entries) = std::fs::read_dir(root) else { return out };
|
||||
for entry in entries.flatten() {
|
||||
let dir = entry.path();
|
||||
let Some(folder) = dir.file_name().and_then(|n| n.to_str()).map(str::to_owned) else { continue };
|
||||
if !dir.is_dir() || folder.starts_with('.') {
|
||||
continue;
|
||||
}
|
||||
let Ok(text) = std::fs::read_to_string(dir.join("SKILL.md")) else { continue };
|
||||
let meta = Frontmatter::parse(&text);
|
||||
let name = meta.get("name").filter(|n| !n.is_empty()).map(str::to_owned).unwrap_or_else(|| folder.clone());
|
||||
let mut warnings = Vec::new();
|
||||
if !valid_name(&name) {
|
||||
warnings.push(format!("`name: {name}` is not 1-64 lowercase letters, digits or hyphens"));
|
||||
}
|
||||
if name != folder {
|
||||
warnings.push(format!("`name: {name}` does not match the folder `{folder}`"));
|
||||
}
|
||||
let description = meta.get("description").unwrap_or_default();
|
||||
let description = strip_ansi(description).trim().to_owned();
|
||||
if description.is_empty() {
|
||||
warnings.push("no `description`: the model never sees when to use it".into());
|
||||
} else if description.chars().count() > MAX_SKILL_DESCRIPTION {
|
||||
warnings.push(format!("`description` is over {MAX_SKILL_DESCRIPTION} characters"));
|
||||
}
|
||||
out.push(AgentSkill {
|
||||
name,
|
||||
description: truncate(&description),
|
||||
path: dir.into(),
|
||||
source,
|
||||
valid: warnings.is_empty(),
|
||||
warnings,
|
||||
});
|
||||
}
|
||||
out.sort_by(|a, b| a.name.cmp(&b.name));
|
||||
out
|
||||
}
|
||||
|
||||
/// A skill's mode, as one policy layer of the settings has it.
|
||||
type Policies = BTreeMap<String, AgentSkillPolicy>;
|
||||
|
||||
/// Resolves every skill's mode: a session override, then the workspace's and the user's
|
||||
/// `[agents.skills.<name>]` policy, then the default `auto` — with an untrusted workspace
|
||||
/// able to turn skills off only: its own skills stay off (whatever the session chose), and
|
||||
/// its policies hold only when they turn a skill off.
|
||||
pub fn resolve(
|
||||
skills: Vec<AgentSkill>,
|
||||
session: Option<&BTreeMap<String, AgentSkillMode>>,
|
||||
workspace: &Policies,
|
||||
user: &Policies,
|
||||
workspace_trusted: bool,
|
||||
) -> Vec<AgentSkillState> {
|
||||
let mut out = Vec::new();
|
||||
for skill in skills {
|
||||
let workspace_skill = matches!(
|
||||
skill.source,
|
||||
AgentSkillSource::Workspace
|
||||
| AgentSkillSource::ClaudeWorkspace
|
||||
| AgentSkillSource::GithubWorkspace
|
||||
| AgentSkillSource::CodexWorkspace
|
||||
| AgentSkillSource::CursorWorkspace
|
||||
);
|
||||
let (mode, origin) = if workspace_skill && !workspace_trusted {
|
||||
// Workspace trust gates the workspace's own skills, whatever else says.
|
||||
(AgentSkillMode::Off, AgentSkillOrigin::Trust)
|
||||
} else if let Some(chosen) = session.and_then(|s| s.get(&skill.name)) {
|
||||
(*chosen, AgentSkillOrigin::Session)
|
||||
} else if let Some(policy) =
|
||||
workspace.get(&skill.name).filter(|p| workspace_trusted || p.mode == AgentSkillMode::Off)
|
||||
{
|
||||
(policy.mode, AgentSkillOrigin::Workspace)
|
||||
} else if let Some(policy) = user.get(&skill.name) {
|
||||
(policy.mode, AgentSkillOrigin::User)
|
||||
} else {
|
||||
(AgentSkillMode::Auto, AgentSkillOrigin::None)
|
||||
};
|
||||
out.push(AgentSkillState { skill, mode, origin });
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// What one CLI session receives for its active skills. Sent to the shims in
|
||||
/// `session/new`'s `_meta.openidea.skills`, so each driver applies its own fields.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
||||
#[serde(rename_all = "camelCase", default)]
|
||||
pub struct Delivery {
|
||||
/// Claude Code: the farm passed as `--add-dir` (its `.claude/skills` holds the staged copies).
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub claude_add_dir: Option<PathBuf>,
|
||||
/// Claude Code: the `--settings` JSON with `skillOverrides` (the native skills too).
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub claude_settings: Option<String>,
|
||||
/// Copilot: `skillDirectories` (the farm's `copilot` tree).
|
||||
#[serde(skip_serializing_if = "Vec::is_empty")]
|
||||
pub copilot_skill_directories: Vec<String>,
|
||||
/// Copilot: `disabledSkills`, spelled as the skills are.
|
||||
#[serde(skip_serializing_if = "Vec::is_empty")]
|
||||
pub copilot_disabled_skills: Vec<String>,
|
||||
/// Codex: `skills/extraRoots/set` roots (the farm's `codex` tree).
|
||||
#[serde(skip_serializing_if = "Vec::is_empty")]
|
||||
pub codex_extra_roots: Vec<String>,
|
||||
/// Codex: `skills.config` entries turning skills off by path.
|
||||
#[serde(skip_serializing_if = "Vec::is_empty")]
|
||||
pub codex_off: Vec<(String, String)>,
|
||||
}
|
||||
|
||||
/// Stages the skills a session of `provider` runs with into `farm` — linking (copying on
|
||||
/// Windows, where directory symlinks need Developer Mode) every active skill folder into
|
||||
/// the CLI's tree — and reports what to hand the CLI. Skills the CLI discovers natively
|
||||
/// (its own folders of the working directory and the home) are not staged again: it already
|
||||
/// sees them, and seeing both would list one skill twice. Skills `off` are never staged;
|
||||
/// the CLI's native disable (where it has one) receives their names or paths. An ACP
|
||||
/// agent gets nothing here: its `/` menu is filtered instead.
|
||||
pub fn stage(
|
||||
farm: &Path,
|
||||
provider: &str,
|
||||
states: &[AgentSkillState],
|
||||
cwd: &Path,
|
||||
home: Option<&Path>,
|
||||
) -> std::io::Result<Delivery> {
|
||||
let mut out = Delivery::default();
|
||||
let cwd = dunce::canonicalize(cwd).unwrap_or_else(|_| cwd.to_path_buf());
|
||||
// Only the native drivers take the farm, each its own tree; `provider` is their key
|
||||
// (`claude`, `copilot`, `codex`), anything else (an ACP agent) gets the `/` menu filter.
|
||||
let (claude_tree, copilot_tree, codex_tree) = match provider {
|
||||
"claude" => (Some(farm.join(".claude/skills")), None, None),
|
||||
"copilot" => (None, Some(farm.join("copilot")), None),
|
||||
"codex" => (None, None, Some(farm.join("codex"))),
|
||||
_ => return Ok(out),
|
||||
};
|
||||
// Restage from scratch: a skill turned off or deleted since the last session must not
|
||||
// linger in the tree. Removing a tree removes its links, never the skills they point at.
|
||||
for tree in [&claude_tree, &copilot_tree, &codex_tree].into_iter().flatten() {
|
||||
match std::fs::remove_dir_all(tree) {
|
||||
Err(e) if e.kind() != std::io::ErrorKind::NotFound => return Err(e),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
for state in states {
|
||||
let name = state.skill.name.as_str();
|
||||
let path = state.skill.path.0.as_path();
|
||||
match state.mode {
|
||||
AgentSkillMode::Off => {
|
||||
out.codex_off.push((name.to_owned(), state.skill.path.to_string_lossy().into_owned()));
|
||||
}
|
||||
// Claude Code runs a slash-only skill on `/name`, so it has to see the folder;
|
||||
// Copilot and Codex have no such mode and get it disabled or left out.
|
||||
AgentSkillMode::SlashOnly => {
|
||||
if let Some(tree) = claude_tree.as_ref().filter(|_| !native_claude(&state.skill, &cwd, home)) {
|
||||
link_skill(&tree.join(name), path)?;
|
||||
}
|
||||
}
|
||||
AgentSkillMode::Auto => {
|
||||
if let Some(tree) = claude_tree.as_ref().filter(|_| !native_claude(&state.skill, &cwd, home)) {
|
||||
link_skill(&tree.join(name), path)?;
|
||||
}
|
||||
if let Some(tree) = copilot_tree.as_ref().filter(|_| !native_copilot(&state.skill, &cwd, home)) {
|
||||
link_skill(&tree.join(name), path)?;
|
||||
}
|
||||
if let Some(tree) = codex_tree.as_ref().filter(|_| !native_codex(&state.skill, &cwd, home)) {
|
||||
link_skill(&tree.join(name), path)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if claude_tree.as_ref().is_some_and(|t| t.exists()) {
|
||||
out.claude_add_dir = Some(farm.to_path_buf());
|
||||
}
|
||||
if let Some(tree) = copilot_tree.as_ref().filter(|t| t.exists()) {
|
||||
out.copilot_skill_directories.push(tree.to_string_lossy().into_owned());
|
||||
}
|
||||
if let Some(tree) = codex_tree.as_ref().filter(|t| t.exists()) {
|
||||
out.codex_extra_roots.push(tree.to_string_lossy().into_owned());
|
||||
}
|
||||
// Claude Code's `skillOverrides` and Copilot's `disabledSkills` take the names of the
|
||||
// off and slash-only skills — the native copies included.
|
||||
let off: Vec<&str> =
|
||||
states.iter().filter(|s| s.mode == AgentSkillMode::Off).map(|s| s.skill.name.as_str()).collect();
|
||||
let slash: Vec<&str> =
|
||||
states.iter().filter(|s| s.mode == AgentSkillMode::SlashOnly).map(|s| s.skill.name.as_str()).collect();
|
||||
if !off.is_empty() || !slash.is_empty() {
|
||||
let mut overrides = serde_json::Map::new();
|
||||
for (name, mode) in off.iter().map(|n| (*n, "off")).chain(slash.iter().map(|n| (*n, "user-invocable-only"))) {
|
||||
overrides.insert(name.to_owned(), serde_json::Value::String(mode.to_owned()));
|
||||
}
|
||||
out.claude_settings = Some(
|
||||
serde_json::to_string(&serde_json::json!({ "skillOverrides": overrides })).expect("settings serialize"),
|
||||
);
|
||||
out.copilot_disabled_skills = off.iter().chain(slash.iter()).map(|n| (*n).to_owned()).collect();
|
||||
out.copilot_disabled_skills.sort();
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Claude Code sees this skill without the farm: its own `.claude/skills` of the working
|
||||
/// directory (a worktree lacks the untracked originals) or the home.
|
||||
fn native_claude(skill: &AgentSkill, cwd: &Path, home: Option<&Path>) -> bool {
|
||||
match skill.source {
|
||||
AgentSkillSource::ClaudeWorkspace => is_under(skill.path.0.as_path(), cwd),
|
||||
AgentSkillSource::ClaudeUser => home.is_some_and(|h| is_under(skill.path.0.as_path(), &h.join(".claude"))),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Copilot reads the repository's `.github/skills` and the home's `.copilot` itself.
|
||||
fn native_copilot(skill: &AgentSkill, cwd: &Path, home: Option<&Path>) -> bool {
|
||||
match skill.source {
|
||||
AgentSkillSource::GithubWorkspace => is_under(skill.path.0.as_path(), cwd),
|
||||
AgentSkillSource::CopilotUser => home.is_some_and(|h| is_under(skill.path.0.as_path(), &h.join(".copilot"))),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Codex reads its own folders itself.
|
||||
fn native_codex(skill: &AgentSkill, cwd: &Path, home: Option<&Path>) -> bool {
|
||||
match skill.source {
|
||||
AgentSkillSource::CodexWorkspace => is_under(skill.path.0.as_path(), cwd),
|
||||
AgentSkillSource::CodexUser => home.is_some_and(|h| is_under(skill.path.0.as_path(), &h.join(".codex"))),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
fn is_under(path: &Path, root: &Path) -> bool {
|
||||
path.starts_with(root)
|
||||
}
|
||||
|
||||
/// Puts `name` into the farm tree: a directory symlink where they work, a copy otherwise
|
||||
/// (Windows needs Developer Mode for directory symlinks).
|
||||
fn link_skill(link: &Path, target: &Path) -> std::io::Result<()> {
|
||||
let _ = std::fs::remove_file(link);
|
||||
if let Some(parent) = link.parent() {
|
||||
std::fs::create_dir_all(parent)?;
|
||||
}
|
||||
#[cfg(unix)]
|
||||
{
|
||||
std::os::unix::fs::symlink(target, link)
|
||||
}
|
||||
#[cfg(windows)]
|
||||
{
|
||||
copy_dir_all(target, link)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn copy_dir_all(from: &Path, to: &Path) -> std::io::Result<()> {
|
||||
std::fs::create_dir_all(to)?;
|
||||
for entry in std::fs::read_dir(from)?.flatten() {
|
||||
let path = entry.path();
|
||||
let dest = to.join(entry.file_name());
|
||||
if path.is_dir() {
|
||||
copy_dir_all(&path, &dest)?;
|
||||
} else {
|
||||
std::fs::copy(&path, &dest)?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Removes a task's farm (task deleted or archived); missing is fine.
|
||||
pub fn remove_farm(store_dir: &Path, task: &str) {
|
||||
let farm = farm_dir(store_dir, task);
|
||||
match std::fs::remove_dir_all(&farm) {
|
||||
Ok(()) => {}
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
|
||||
Err(e) => tracing::warn!("removing the session skills folder {}: {e}", farm.display()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Where a task's staged skills live.
|
||||
pub fn farm_dir(store_dir: &Path, task: &str) -> PathBuf {
|
||||
store_dir.join("session-skills").join(sanitized(task))
|
||||
}
|
||||
|
||||
/// A task id is a uuid, but never trust it with a path segment.
|
||||
fn sanitized(id: &str) -> String {
|
||||
id.chars().filter(|c| c.is_ascii_alphanumeric() || *c == '-').collect()
|
||||
}
|
||||
|
||||
/// The `/` menu's skills: the active ones as commands (the agent's own listing wins on a
|
||||
/// name clash). `Off` ones drop out everywhere; an ACP agent gets no other enforcement, so
|
||||
/// `slashOnly` ones stay listed — there is nothing to hold them back with.
|
||||
pub fn menu_commands(offered: Vec<AgentCommand>, states: &[AgentSkillState]) -> Vec<AgentCommand> {
|
||||
let extra = states
|
||||
.iter()
|
||||
.filter(|s| s.mode != AgentSkillMode::Off)
|
||||
.map(|s| AgentCommand {
|
||||
name: s.skill.name.clone(),
|
||||
description: s.skill.description.clone(),
|
||||
hint: None,
|
||||
source: AgentCommandSource::Skill,
|
||||
})
|
||||
.collect();
|
||||
merge(offered, extra)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -703,231 +333,4 @@ mod tests {
|
||||
assert_eq!(f.get("name"), Some("quoted"));
|
||||
assert_eq!(truncate(&"é".repeat(MAX_DESCRIPTION + 5)).chars().count(), MAX_DESCRIPTION + 1);
|
||||
}
|
||||
|
||||
fn skill(name: &str, source: AgentSkillSource, root: &Path) -> AgentSkill {
|
||||
AgentSkill {
|
||||
name: name.into(),
|
||||
description: format!("{name} does things"),
|
||||
path: root.join(name).into(),
|
||||
source,
|
||||
valid: true,
|
||||
warnings: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn policy(mode: AgentSkillMode) -> Option<AgentSkillPolicy> {
|
||||
Some(AgentSkillPolicy { mode })
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hub_discovery_scans_every_root_and_collapses_symlinks() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let home = tmp.path().join("home");
|
||||
let repo = tmp.path().join("work/app");
|
||||
std::fs::create_dir_all(&repo).unwrap();
|
||||
write(&repo.join(".agents/skills/dep/SKILL.md"), "---\nname: dep\ndescription: From the standard root\n---\n");
|
||||
write(&repo.join(".openidea/skills/local/SKILL.md"), "---\nname: local\ndescription: OpenIDEA's own\n---\n");
|
||||
write(&repo.join(".claude/skills/claudey/SKILL.md"), "---\nname: claudey\ndescription: Claude's\n---\n");
|
||||
write(&repo.join(".github/skills/gh/SKILL.md"), "---\nname: gh\ndescription: Copilot's repo one\n---\n");
|
||||
write(
|
||||
&home.join(".agents/skills/shared/SKILL.md"),
|
||||
"---\nname: shared\ndescription: From npx skills add\n---\n",
|
||||
);
|
||||
write(&home.join(".codex/skills/codexy/SKILL.md"), "---\nname: codexy\ndescription: Codex's\n---\n");
|
||||
write(&home.join(".cursor/skills/cursory/SKILL.md"), "---\nname: cursory\ndescription: Cursor's\n---\n");
|
||||
// A symlink to `dep` in the home (the same canonical folder): collapsed.
|
||||
#[cfg(unix)]
|
||||
{
|
||||
std::fs::create_dir_all(home.join(".claude/skills")).unwrap();
|
||||
std::os::unix::fs::symlink(repo.join(".agents/skills/dep"), home.join(".claude/skills/dep")).unwrap();
|
||||
}
|
||||
// Hidden folders and files are not skills.
|
||||
write(&repo.join(".agents/skills/.stash/SKILL.md"), "---\nname: hidden\ndescription: x\n---\n");
|
||||
write(&repo.join(".agents/skills/loose.txt"), "not a folder");
|
||||
// Same name from a lower-precedence source: the workspace one wins.
|
||||
write(&home.join(".cursor/skills/local/SKILL.md"), "---\nname: local\ndescription: from cursor\n---\n");
|
||||
|
||||
let found = discover_skills(&repo, Some(&home));
|
||||
assert_eq!(
|
||||
found.iter().map(|s| (s.name.as_str(), s.source)).collect::<Vec<_>>(),
|
||||
[
|
||||
("dep", AgentSkillSource::Workspace),
|
||||
("local", AgentSkillSource::Workspace),
|
||||
("claudey", AgentSkillSource::ClaudeWorkspace),
|
||||
("gh", AgentSkillSource::GithubWorkspace),
|
||||
("shared", AgentSkillSource::User),
|
||||
("codexy", AgentSkillSource::CodexUser),
|
||||
("cursory", AgentSkillSource::CursorUser),
|
||||
],
|
||||
"symlinks collapse and the first of a name wins"
|
||||
);
|
||||
assert!(found.iter().all(|s| s.valid), "{:?}", found.iter().flat_map(|s| &s.warnings).collect::<Vec<_>>());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hub_discovery_validates_and_reports() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let repo = tmp.path().join("app");
|
||||
std::fs::create_dir_all(&repo).unwrap();
|
||||
write(&repo.join(".agents/skills/bad-name/SKILL.md"), "---\nname: Bad_Name\ndescription: x\n---\n");
|
||||
write(&repo.join(".agents/skills/no-desc/SKILL.md"), "---\nname: no-desc\n---\n");
|
||||
write(
|
||||
&repo.join(".agents/skills/verbose/SKILL.md"),
|
||||
&format!("---\nname: verbose\ndescription: {}\n---\n", "x".repeat(MAX_SKILL_DESCRIPTION + 1)),
|
||||
);
|
||||
|
||||
let found = discover_skills(&repo, None);
|
||||
let by = |n: &str| found.iter().find(|s| s.name == n).unwrap();
|
||||
assert!(!by("Bad_Name").valid && !by("Bad_Name").warnings.is_empty());
|
||||
assert!(!by("no-desc").valid && by("no-desc").warnings.len() == 1);
|
||||
assert!(!by("verbose").valid);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hub_resolution_precedence_and_trust() {
|
||||
let root = PathBuf::from("/r");
|
||||
let ws = skill("tdd", AgentSkillSource::Workspace, &root);
|
||||
let user = skill("lint", AgentSkillSource::User, &root);
|
||||
let claude = skill("claudey", AgentSkillSource::ClaudeWorkspace, &root);
|
||||
let session = BTreeMap::from([("tdd".to_owned(), AgentSkillMode::Off)]);
|
||||
let workspace = BTreeMap::from([
|
||||
("tdd".to_owned(), policy(AgentSkillMode::SlashOnly).unwrap()),
|
||||
("lint".to_owned(), policy(AgentSkillMode::Off).unwrap()),
|
||||
]);
|
||||
let user_policies = BTreeMap::from([
|
||||
("lint".to_owned(), policy(AgentSkillMode::SlashOnly).unwrap()),
|
||||
("claudey".to_owned(), policy(AgentSkillMode::Auto).unwrap()),
|
||||
]);
|
||||
|
||||
// Session > workspace policy > user policy.
|
||||
let resolved = resolve(vec![ws.clone(), user.clone()], Some(&session), &workspace, &user_policies, true);
|
||||
assert_eq!((resolved[0].mode, resolved[0].origin), (AgentSkillMode::Off, AgentSkillOrigin::Session));
|
||||
assert_eq!((resolved[1].mode, resolved[1].origin), (AgentSkillMode::Off, AgentSkillOrigin::Workspace));
|
||||
|
||||
// Without a workspace policy the user's applies.
|
||||
let resolved = resolve(vec![user.clone()], None, &BTreeMap::new(), &user_policies, true);
|
||||
assert_eq!((resolved[0].mode, resolved[0].origin), (AgentSkillMode::SlashOnly, AgentSkillOrigin::User));
|
||||
|
||||
// Untrusted: the workspace's own skills stay off whatever the session chose, its
|
||||
// policies hold only when they turn a skill off, and user skills keep resolving.
|
||||
let resolved = resolve(vec![ws, user, claude], Some(&session), &workspace, &user_policies, false);
|
||||
assert_eq!((resolved[0].mode, resolved[0].origin), (AgentSkillMode::Off, AgentSkillOrigin::Trust));
|
||||
assert_eq!((resolved[1].mode, resolved[1].origin), (AgentSkillMode::Off, AgentSkillOrigin::Workspace));
|
||||
assert_eq!((resolved[2].mode, resolved[2].origin), (AgentSkillMode::Off, AgentSkillOrigin::Trust));
|
||||
}
|
||||
|
||||
fn listed(dir: &Path) -> Vec<String> {
|
||||
let mut names: Vec<String> =
|
||||
std::fs::read_dir(dir).unwrap().flatten().map(|e| e.file_name().to_string_lossy().into_owned()).collect();
|
||||
names.sort();
|
||||
names
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hub_staging_hands_each_cli_its_own_tree() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
// Discovery reports canonical paths (macOS's temp folder is a symlink).
|
||||
let root = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let home = root.join("home");
|
||||
let repo = root.join("app");
|
||||
std::fs::create_dir_all(&repo).unwrap();
|
||||
// The staged folders must exist: Windows copies them (symlinks need Developer Mode).
|
||||
for path in [
|
||||
repo.join(".agents/skills/tdd"),
|
||||
repo.join(".agents/skills/off"),
|
||||
repo.join(".github/skills/gh"),
|
||||
home.join(".agents/skills/lint"),
|
||||
home.join(".agents/skills/muted"),
|
||||
home.join(".codex/skills/codexy"),
|
||||
] {
|
||||
std::fs::create_dir_all(path).unwrap();
|
||||
}
|
||||
let states = resolve(
|
||||
vec![
|
||||
skill("tdd", AgentSkillSource::Workspace, &repo.join(".agents/skills")),
|
||||
skill("gh", AgentSkillSource::GithubWorkspace, &repo.join(".github/skills")),
|
||||
skill("lint", AgentSkillSource::User, &home.join(".agents/skills")),
|
||||
skill("codexy", AgentSkillSource::CodexUser, &home.join(".codex/skills")),
|
||||
skill("muted", AgentSkillSource::User, &home.join(".agents/skills")),
|
||||
skill("off", AgentSkillSource::Workspace, &repo.join(".agents/skills")),
|
||||
],
|
||||
None,
|
||||
&BTreeMap::from([("muted".to_owned(), policy(AgentSkillMode::SlashOnly).unwrap())]),
|
||||
&BTreeMap::from([("off".to_owned(), policy(AgentSkillMode::Off).unwrap())]),
|
||||
true,
|
||||
);
|
||||
|
||||
// Local (non-worktree) session: the project's GitHub skills are Copilot's own.
|
||||
let farm = farm_dir(&root.join("store"), "task-1");
|
||||
let delivery = stage(&farm, "claude", &states, &repo, Some(&home)).unwrap();
|
||||
assert_eq!(delivery.claude_add_dir.as_deref(), Some(farm.as_path()));
|
||||
let claude_tree = farm.join(".claude/skills");
|
||||
let staged = listed(&claude_tree);
|
||||
assert_eq!(
|
||||
staged,
|
||||
["codexy", "gh", "lint", "muted", "tdd"],
|
||||
"everything but the off one: none is native to Claude here, and slash-only needs the folder"
|
||||
);
|
||||
|
||||
let delivery = stage(&farm, "copilot", &states, &repo, Some(&home)).unwrap();
|
||||
assert_eq!(delivery.copilot_skill_directories, [farm.join("copilot").to_string_lossy().into_owned()]);
|
||||
assert_eq!(delivery.copilot_disabled_skills, ["muted", "off"]);
|
||||
let copilot_staged = listed(&farm.join("copilot"));
|
||||
assert_eq!(copilot_staged, ["codexy", "lint", "tdd"], "`gh` is native to a local Copilot session");
|
||||
assert_eq!(
|
||||
delivery.codex_off,
|
||||
[("off".to_owned(), repo.join(".agents/skills").join("off").to_string_lossy().into_owned())]
|
||||
);
|
||||
|
||||
// A worktree task: the repo's skills are untracked, so nothing is native any more.
|
||||
let worktree = root.join("wt");
|
||||
std::fs::create_dir_all(&worktree).unwrap();
|
||||
let _ = stage(&farm, "copilot", &states, &worktree, Some(&home)).unwrap();
|
||||
let copilot_staged = listed(&farm.join("copilot"));
|
||||
assert!(copilot_staged.contains(&"gh".to_string()));
|
||||
|
||||
// Slash-only reaches Claude as `user-invocable-only`, off as `off`.
|
||||
let delivery = stage(&farm, "claude", &states, &repo, Some(&home)).unwrap();
|
||||
let settings: serde_json::Value = serde_json::from_str(delivery.claude_settings.as_deref().unwrap()).unwrap();
|
||||
assert_eq!(settings["skillOverrides"]["muted"], "user-invocable-only");
|
||||
assert_eq!(settings["skillOverrides"]["off"], "off");
|
||||
|
||||
// Restaging after a session turned `lint` off drops its link and leaves the skill.
|
||||
let session = BTreeMap::from([("lint".to_owned(), AgentSkillMode::Off)]);
|
||||
let restated = resolve(
|
||||
states.iter().map(|s| s.skill.clone()).collect(),
|
||||
Some(&session),
|
||||
&BTreeMap::from([("muted".to_owned(), policy(AgentSkillMode::SlashOnly).unwrap())]),
|
||||
&BTreeMap::from([("off".to_owned(), policy(AgentSkillMode::Off).unwrap())]),
|
||||
true,
|
||||
);
|
||||
stage(&farm, "claude", &restated, &repo, Some(&home)).unwrap();
|
||||
assert_eq!(listed(&claude_tree), ["codexy", "gh", "muted", "tdd"]);
|
||||
assert!(home.join(".agents/skills/lint").is_dir());
|
||||
assert!(farm.join("copilot").is_dir(), "restaging Claude's tree leaves Copilot's alone");
|
||||
|
||||
// An ACP agent gets no farm.
|
||||
let delivery = stage(&farm, "cursor-acp", &states, &repo, Some(&home)).unwrap();
|
||||
assert_eq!(delivery, Delivery::default());
|
||||
|
||||
// The farm goes away with the task.
|
||||
remove_farm(&root.join("store"), "task-1");
|
||||
assert!(!farm.exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hub_menu_filters_off_and_keeps_the_agents_own() {
|
||||
let root = PathBuf::from("/r");
|
||||
let states = resolve(
|
||||
vec![skill("tdd", AgentSkillSource::Workspace, &root), skill("lint", AgentSkillSource::User, &root)],
|
||||
Some(&BTreeMap::from([("lint".to_owned(), AgentSkillMode::Off)])),
|
||||
&BTreeMap::new(),
|
||||
&BTreeMap::new(),
|
||||
true,
|
||||
);
|
||||
let menu = menu_commands(vec![cmd("tdd", "from the agent itself")], &states);
|
||||
assert_eq!(names(&menu), ["tdd"]);
|
||||
assert_eq!(menu[0].description, "from the agent itself");
|
||||
assert_eq!(menu[0].source, AgentCommandSource::Skill);
|
||||
}
|
||||
}
|
||||
@@ -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");
|
||||
@@ -4532,7 +4503,6 @@ async fn per_session_mcp_overrides_filter_session_and_reload_when_idle() {
|
||||
base: None,
|
||||
mcp_overrides: BTreeMap::from([("slack".into(), false)]),
|
||||
idle: false,
|
||||
skill_overrides: BTreeMap::new(),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -4661,7 +4631,6 @@ async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails()
|
||||
base: None,
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
idle: false,
|
||||
skill_overrides: BTreeMap::new(),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -4687,7 +4656,6 @@ async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails()
|
||||
base: None,
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
idle: false,
|
||||
skill_overrides: BTreeMap::new(),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
@@ -4766,10 +4734,10 @@ done
|
||||
#[test]
|
||||
fn session_params_name_the_servers_off() {
|
||||
let mcp = McpForSession { servers: vec![json!({ "name": "docs" })], off: vec!["github".into()] };
|
||||
let params = session_params("/p", &mcp, None);
|
||||
let params = session_params("/p", &mcp);
|
||||
assert_eq!(params["cwd"], "/p");
|
||||
assert_eq!(params["mcpServers"][0]["name"], "docs");
|
||||
assert_eq!(params["_meta"]["openidea"]["mcpServersOff"], json!(["github"]));
|
||||
let none = McpForSession { servers: Vec::new(), off: Vec::new() };
|
||||
assert!(session_params("/p", &none, None).get("_meta").is_none());
|
||||
assert!(session_params("/p", &none).get("_meta").is_none());
|
||||
}
|
||||
@@ -82,23 +82,11 @@ pub fn load_linked(
|
||||
maven_repo: Option<PathBuf>,
|
||||
settings: &ide_core::settings::MavenSettings,
|
||||
gradle_settings: &ide_core::settings::GradleSettings,
|
||||
) -> BuildModel {
|
||||
load_linked_with_jdk(root, cache_dir, maven_repo, settings, gradle_settings, None)
|
||||
}
|
||||
|
||||
/// [`load_linked`] with the JDK Maven runs on, for JDK-activated Maven profiles.
|
||||
pub fn load_linked_with_jdk(
|
||||
root: &Path,
|
||||
cache_dir: &Path,
|
||||
maven_repo: Option<PathBuf>,
|
||||
settings: &ide_core::settings::MavenSettings,
|
||||
gradle_settings: &ide_core::settings::GradleSettings,
|
||||
maven_jdk_version: Option<u32>,
|
||||
) -> BuildModel {
|
||||
let maven = maven::has_projects(root, settings).then(|| {
|
||||
let profiles = settings.profiles(&sync::maven_profiles(cache_dir));
|
||||
let repo = maven_repo.or_else(maven::default_local_repo);
|
||||
let mut m = maven::load_with_linked_jdk(root, repo, &profiles, maven_jdk_version, &settings.linked_projects);
|
||||
let mut m = maven::load_with_linked(root, repo, &profiles, &settings.linked_projects);
|
||||
maven::UnlinkedProjects::from_model(&m, settings).filter(&mut m);
|
||||
// The user settings' profiles can be chosen too (`-P` applies to them as well).
|
||||
for p in maven::user_settings_file(root, settings).map(|f| maven::settings_profiles(&f)).unwrap_or_default() {
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -92,18 +92,10 @@ pub enum IdeEvent {
|
||||
/// Text version when this transition occurred, including when it was saved.
|
||||
version: u32,
|
||||
},
|
||||
/// An open document's file changed on disk while the buffer had unsaved changes. The buffer
|
||||
/// keeps them (autosave leaves the file alone); the UI offers to load the disk version.
|
||||
DocDiskConflict {
|
||||
doc: DocId,
|
||||
path: String,
|
||||
},
|
||||
/// A complete workspace edit can be undone as one operation.
|
||||
WorkspaceEditApplied {
|
||||
id: u32,
|
||||
paths: Vec<crate::IpcPath>,
|
||||
/// Files the edit renamed, as the edit named them: editors open on them follow.
|
||||
moves: Vec<crate::FileMove>,
|
||||
/// Made by an agent through the MCP server's tools: undoable like a refactoring, but
|
||||
/// not announced as one.
|
||||
by_agent: bool,
|
||||
|
||||
@@ -15,7 +15,6 @@ pub mod inspection_settings;
|
||||
pub mod ipc_path;
|
||||
pub mod java_runtime;
|
||||
pub mod jsonc;
|
||||
pub mod memory;
|
||||
pub mod output_encoding;
|
||||
pub mod platform;
|
||||
pub mod process;
|
||||
|
||||
@@ -1,20 +0,0 @@
|
||||
//! Returning freed heap pages to the OS.
|
||||
|
||||
/// Hands pages the allocator has freed but kept back to the OS. Call after a burst of
|
||||
/// short-lived allocations (a full index scan); until then they still count towards the
|
||||
/// process's memory footprint.
|
||||
pub fn release_free_pages() {
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
unsafe extern "C" {
|
||||
fn malloc_zone_pressure_relief(zone: *mut std::ffi::c_void, goal: usize) -> usize;
|
||||
}
|
||||
// SAFETY: a null zone covers every zone; a zero goal releases as much as possible.
|
||||
unsafe { malloc_zone_pressure_relief(std::ptr::null_mut(), 0) };
|
||||
}
|
||||
#[cfg(all(target_os = "linux", target_env = "gnu"))]
|
||||
// SAFETY: malloc_trim only returns free memory to the OS.
|
||||
unsafe {
|
||||
libc::malloc_trim(0);
|
||||
}
|
||||
}
|
||||
@@ -130,11 +130,6 @@ pub struct AgentSettings {
|
||||
#[serde(deserialize_with = "or_default")]
|
||||
#[specta(type = BTreeMap<String, AgentMcpServer>)]
|
||||
pub mcp_servers: BTreeMap<String, AgentMcpServer>,
|
||||
/// How agent skills may run, keyed by skill name (`[agents.skills.<name>]`); `SKILL.md`
|
||||
/// files on disk are never modified.
|
||||
#[serde(deserialize_with = "or_default")]
|
||||
#[specta(type = BTreeMap<String, AgentSkillPolicy>)]
|
||||
pub skills: BTreeMap<String, AgentSkillPolicy>,
|
||||
}
|
||||
|
||||
impl Default for AgentSettings {
|
||||
@@ -155,7 +150,6 @@ impl Default for AgentSettings {
|
||||
new_task_approvals: NewTaskApprovals::Bypass,
|
||||
defaults: BTreeMap::new(),
|
||||
mcp_servers: BTreeMap::new(),
|
||||
skills: BTreeMap::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -211,34 +205,6 @@ impl Default for AgentMcpServer {
|
||||
}
|
||||
}
|
||||
|
||||
/// How an agent skill may run (`[agents.skills.<name>] mode = …`).
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum AgentSkillMode {
|
||||
/// The model decides when to use it.
|
||||
#[default]
|
||||
Auto,
|
||||
/// Only when the user invokes it with `/name`.
|
||||
SlashOnly,
|
||||
/// Never.
|
||||
Off,
|
||||
}
|
||||
|
||||
/// A skill's policy in Settings › Agents › Skills, stored without touching its `SKILL.md`.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct AgentSkillPolicy {
|
||||
#[serde(deserialize_with = "or_default")]
|
||||
#[specta(type = AgentSkillMode)]
|
||||
pub mode: AgentSkillMode,
|
||||
}
|
||||
|
||||
impl Default for AgentSkillPolicy {
|
||||
fn default() -> Self {
|
||||
Self { mode: AgentSkillMode::Auto }
|
||||
}
|
||||
}
|
||||
|
||||
/// A hand-edited value these settings don't know reads as the default, rather than
|
||||
/// failing the whole settings file.
|
||||
fn or_default<'de, D, T>(d: D) -> Result<T, D::Error>
|
||||
|
||||
@@ -110,17 +110,6 @@ pub struct WorkspaceEditPrecondition {
|
||||
}
|
||||
|
||||
impl WorkspaceEdit {
|
||||
/// The files and folders the edit renames, in order.
|
||||
pub fn moves(&self) -> Vec<FileMove> {
|
||||
self.files
|
||||
.iter()
|
||||
.filter_map(|f| match f {
|
||||
FileEdit::Rename { from, to } => Some(FileMove { from: from.clone(), to: to.clone() }),
|
||||
_ => None,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Coalesces aliases of the same file before applying edits against its original text.
|
||||
/// Resource operations separate batches because later edits may use the new contents.
|
||||
pub fn deduplicate(&mut self) {
|
||||
@@ -195,14 +184,6 @@ pub enum FileEdit {
|
||||
},
|
||||
}
|
||||
|
||||
/// One file or folder move.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct FileMove {
|
||||
pub from: crate::IpcPath,
|
||||
pub to: crate::IpcPath,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum Severity {
|
||||
|
||||
@@ -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(),
|
||||
@@ -79,8 +76,6 @@ pub struct GitSettings {
|
||||
/// label is plain text and a click on it places the caret as past the line end.
|
||||
pub inline_blame_clickable: bool,
|
||||
pub show_branch_in_project_view: bool,
|
||||
/// Branch operations from the branches popup act on every repository of the project.
|
||||
pub sync_branch_operations: bool,
|
||||
/// Path to the git executable; empty = auto-detect.
|
||||
pub executable: String,
|
||||
/// Default of Update Project: `merge` | `rebase`.
|
||||
@@ -122,7 +117,6 @@ impl Default for GitSettings {
|
||||
inline_blame: false,
|
||||
inline_blame_clickable: true,
|
||||
show_branch_in_project_view: false,
|
||||
sync_branch_operations: true,
|
||||
executable: String::new(),
|
||||
update_method: "merge".into(),
|
||||
auto_update_on_push_rejected: false,
|
||||
@@ -151,7 +145,6 @@ pub struct CommitSettings {
|
||||
/// Commit from the Commit tool window; off = Local Changes in the Git tool
|
||||
/// window and a Commit dialog.
|
||||
pub non_modal: bool,
|
||||
pub include_changes_by_default: bool,
|
||||
/// Start with an empty message instead of the last one / the changelist's.
|
||||
pub clear_initial_message: bool,
|
||||
pub analyze_code: bool,
|
||||
@@ -183,15 +176,12 @@ pub struct CommitSettings {
|
||||
pub agent_model: String,
|
||||
/// That model's thinking level for commit messages; empty keeps the agent's.
|
||||
pub agent_effort: String,
|
||||
/// Show the Generate Commit Message with Agent button above the commit message.
|
||||
pub agent_button: bool,
|
||||
}
|
||||
|
||||
impl Default for CommitSettings {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
non_modal: true,
|
||||
include_changes_by_default: true,
|
||||
clear_initial_message: false,
|
||||
analyze_code: true,
|
||||
check_todo: true,
|
||||
@@ -211,7 +201,6 @@ impl Default for CommitSettings {
|
||||
agent: String::new(),
|
||||
agent_model: String::new(),
|
||||
agent_effort: String::new(),
|
||||
agent_button: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -617,16 +606,3 @@ impl Default for AgentSecuritySettings {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn git_settings_without_sync_key_execute_on_all_repositories() {
|
||||
let missing: GitSettings = serde_json::from_str("{}").unwrap();
|
||||
assert!(missing.sync_branch_operations);
|
||||
let off: GitSettings = serde_json::from_str(r#"{"syncBranchOperations":false}"#).unwrap();
|
||||
assert!(!off.sync_branch_operations);
|
||||
}
|
||||
}
|
||||
@@ -49,8 +49,6 @@ pub struct AdapterSpec {
|
||||
pub connect: Option<String>,
|
||||
/// A plugin language's adapter: start exactly this approved program.
|
||||
pub pinned: Option<ProgramPin>,
|
||||
/// See [`DebuggerConfig::resolve_lazy_variables`].
|
||||
pub resolve_lazy_variables: bool,
|
||||
}
|
||||
|
||||
/// Built-in adapters used when no language definition names `adapter`.
|
||||
@@ -62,7 +60,6 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
|
||||
transport: transport.to_owned(),
|
||||
connect: None,
|
||||
install_hint: Some(hint.to_owned()),
|
||||
resolve_lazy_variables: false,
|
||||
pinned: None,
|
||||
};
|
||||
Some(match adapter {
|
||||
@@ -133,15 +130,12 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
|
||||
),
|
||||
"rdbg" => cfg("rdbg", &["-O", "--port", PORT_PLACEHOLDER, "-c"], "tcp", "gem install debug"),
|
||||
// A jdtls bundle: the session is started through jdtls and reached via `debugServer`.
|
||||
"java-debug" => DebuggerConfig {
|
||||
resolve_lazy_variables: true,
|
||||
..cfg(
|
||||
"com.microsoft.java.debug.plugin.jar",
|
||||
&[],
|
||||
"tcp",
|
||||
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
|
||||
)
|
||||
},
|
||||
"java-debug" => cfg(
|
||||
"com.microsoft.java.debug.plugin.jar",
|
||||
&[],
|
||||
"tcp",
|
||||
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
|
||||
),
|
||||
// The Java language server's own debugger, for modules jdtls doesn't serve; the host
|
||||
// runs the executable of the java-analyzer serving the module.
|
||||
JAVA_ANALYZER => cfg(
|
||||
@@ -192,7 +186,6 @@ pub fn resolve(config: &DebuggerConfig, cwd: PathBuf) -> AdapterSpec {
|
||||
server_host: None,
|
||||
connect: config.connect.clone(),
|
||||
pinned: config.pinned.clone(),
|
||||
resolve_lazy_variables: config.resolve_lazy_variables,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -102,7 +102,6 @@ pub(crate) fn bare_session_of(name: &str, request: &str) -> BareSession {
|
||||
server_host: None,
|
||||
connect: None,
|
||||
pinned: None,
|
||||
resolve_lazy_variables: false,
|
||||
};
|
||||
let session = Session::new(
|
||||
DebugSessionId(1),
|
||||
|
||||
@@ -236,11 +236,6 @@ pub struct Variable {
|
||||
/// > 0 when expandable.
|
||||
pub variables_reference: i64,
|
||||
pub evaluate_name: Option<String>,
|
||||
/// `value` is not computed yet (DAP `presentationHint.lazy`): the single variable that
|
||||
/// `variables` returns for `variables_reference` holds the value and its children.
|
||||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||||
#[specta(optional)]
|
||||
pub lazy: bool,
|
||||
}
|
||||
|
||||
/// A completion the adapter offers for an expression (DAP `completions`).
|
||||
@@ -732,46 +727,9 @@ pub(crate) fn variable_from(v: &Value) -> Variable {
|
||||
type_name: s("type").filter(|t| !t.is_empty()),
|
||||
variables_reference: v.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
|
||||
evaluate_name: s("evaluateName"),
|
||||
lazy: v.pointer("/presentationHint/lazy").and_then(Value::as_bool).unwrap_or(false),
|
||||
}
|
||||
}
|
||||
|
||||
async fn session_variables(session: &Session, reference: i64) -> IdeResult<Vec<Variable>> {
|
||||
let body =
|
||||
session.conn.request_timeout("variables", json!({ "variablesReference": reference }), REQUEST_TIMEOUT).await?;
|
||||
Ok(body
|
||||
.get("variables")
|
||||
.and_then(Value::as_array)
|
||||
.map(|v| v.iter().map(variable_from).collect())
|
||||
.unwrap_or_default())
|
||||
}
|
||||
|
||||
async fn resolve_in(session: &Session, variable: Variable) -> IdeResult<Variable> {
|
||||
if !variable.lazy || variable.variables_reference <= 0 {
|
||||
return Ok(variable);
|
||||
}
|
||||
let mut inner = session_variables(session, variable.variables_reference).await?;
|
||||
Ok(match (inner.pop(), inner.is_empty()) {
|
||||
(Some(value), true) => Variable {
|
||||
type_name: value.type_name.or(variable.type_name),
|
||||
evaluate_name: variable.evaluate_name.or(value.evaluate_name),
|
||||
name: variable.name,
|
||||
value: value.value,
|
||||
variables_reference: value.variables_reference,
|
||||
lazy: value.lazy,
|
||||
},
|
||||
_ => variable,
|
||||
})
|
||||
}
|
||||
|
||||
/// A value that cannot be computed stays lazy, so the row can still be opened by hand.
|
||||
async fn resolve_lazy(session: &Session, variable: Variable) -> Variable {
|
||||
if !variable.lazy {
|
||||
return variable;
|
||||
}
|
||||
resolve_in(session, variable.clone()).await.unwrap_or(variable)
|
||||
}
|
||||
|
||||
impl DebugManager {
|
||||
pub fn new(languages: Arc<LanguageRegistry>) -> Arc<Self> {
|
||||
Self::with_launcher(languages, Arc::new(ProcessLauncher))
|
||||
@@ -1539,7 +1497,6 @@ impl DebugManager {
|
||||
type_name: body.get("type").and_then(Value::as_str).filter(|t| !t.is_empty()).map(str::to_owned),
|
||||
variables_reference: body.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
|
||||
evaluate_name: evaluate_name.or(Some(name)),
|
||||
lazy: false,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -1610,18 +1567,16 @@ impl DebugManager {
|
||||
}
|
||||
|
||||
pub async fn variables(&self, s: DebugSessionId, reference: i64) -> IdeResult<Vec<Variable>> {
|
||||
let session = self.session(s)?;
|
||||
let vars = session_variables(&session, reference).await?;
|
||||
if !session.spec.resolve_lazy_variables {
|
||||
return Ok(vars);
|
||||
}
|
||||
Ok(join_all(vars.into_iter().map(|v| resolve_lazy(&session, v))).await)
|
||||
}
|
||||
|
||||
/// Computes a lazy variable's value (DAP `presentationHint.lazy`); any other variable, or one
|
||||
/// whose value the adapter does not give as a single variable, comes back unchanged.
|
||||
pub async fn resolve_variable(&self, s: DebugSessionId, variable: Variable) -> IdeResult<Variable> {
|
||||
resolve_in(&*self.session(s)?, variable).await
|
||||
let body = self
|
||||
.session(s)?
|
||||
.conn
|
||||
.request_timeout("variables", json!({ "variablesReference": reference }), REQUEST_TIMEOUT)
|
||||
.await?;
|
||||
Ok(body
|
||||
.get("variables")
|
||||
.and_then(Value::as_array)
|
||||
.map(|v| v.iter().map(variable_from).collect())
|
||||
.unwrap_or_default())
|
||||
}
|
||||
|
||||
/// Evaluates in the `repl` context.
|
||||
@@ -1647,18 +1602,13 @@ impl DebugManager {
|
||||
args["frameId"] = f.into();
|
||||
}
|
||||
let body = session.conn.request_timeout("evaluate", args, REQUEST_TIMEOUT).await?;
|
||||
let result = Variable {
|
||||
Ok(Variable {
|
||||
name: expression.clone(),
|
||||
value: body.get("result").and_then(Value::as_str).unwrap_or_default().to_owned(),
|
||||
type_name: body.get("type").and_then(Value::as_str).filter(|t| !t.is_empty()).map(str::to_owned),
|
||||
variables_reference: body.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
|
||||
evaluate_name: Some(expression),
|
||||
lazy: body.pointer("/presentationHint/lazy").and_then(Value::as_bool).unwrap_or(false),
|
||||
};
|
||||
if !session.spec.resolve_lazy_variables {
|
||||
return Ok(result);
|
||||
}
|
||||
Ok(resolve_lazy(&session, result).await)
|
||||
})
|
||||
}
|
||||
|
||||
/// Completions for `text` at `line` / `column` (0-based, UTF-16) in the frame's scope; none
|
||||
@@ -1763,7 +1713,7 @@ impl DebugManager {
|
||||
// A step runs its thread; other threads stopped by their own events stay stopped.
|
||||
session.suspended.resumed(ticket, thread_id, false);
|
||||
stream_trace::release_done(&session);
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: false });
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1875,7 +1825,7 @@ impl DebugManager {
|
||||
step_settled(&session, sent)?;
|
||||
session.suspended.resumed(ticket, thread_id, false);
|
||||
stream_trace::release_done(&session);
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: false });
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
@@ -505,29 +505,13 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
"scopes" => {
|
||||
ok!(msg, json!({"scopes": [{"name": "Locals", "variablesReference": 100, "expensive": false}]}))
|
||||
}
|
||||
// 200 holds a lazy value (java-debug's toString(), js-debug's getters): asked for, its
|
||||
// reference answers one nameless child with the value and the reference of its fields.
|
||||
"variables" => match msg["arguments"]["variablesReference"].as_i64() {
|
||||
Some(200) => ok!(
|
||||
msg,
|
||||
json!({"variables": [
|
||||
{"name": "order", "value": "Order@7", "type": "Order", "variablesReference": 201,
|
||||
"evaluateName": "order", "presentationHint": {"lazy": true}},
|
||||
{"name": "n", "value": "2", "type": "int", "variablesReference": 0, "presentationHint": {"lazy": false}},
|
||||
]})
|
||||
),
|
||||
Some(201) => ok!(
|
||||
msg,
|
||||
json!({"variables": [{"name": "", "value": "Order@7 \"Order(1)\"", "variablesReference": 202, "evaluateName": "order"}]})
|
||||
),
|
||||
_ => ok!(
|
||||
msg,
|
||||
json!({"variables": [
|
||||
{"name": "x", "value": "1", "type": "int", "variablesReference": 0},
|
||||
{"name": "req", "value": "{Req}", "type": "Req", "variablesReference": 101, "evaluateName": "req"},
|
||||
]})
|
||||
),
|
||||
},
|
||||
"variables" => ok!(
|
||||
msg,
|
||||
json!({"variables": [
|
||||
{"name": "x", "value": "1", "type": "int", "variablesReference": 0},
|
||||
{"name": "req", "value": "{Req}", "type": "Req", "variablesReference": 101, "evaluateName": "req"},
|
||||
]})
|
||||
),
|
||||
"evaluate" => ok!(msg, json!({"result": "42", "type": "int", "variablesReference": 0})),
|
||||
"completions" => ok!(
|
||||
msg,
|
||||
@@ -2036,7 +2020,6 @@ fn godot_registry(port: u16, command: &str, args: &[&str]) -> Arc<LanguageRegist
|
||||
transport: "tcp".into(),
|
||||
connect: Some(format!("127.0.0.1:{port}")),
|
||||
install_hint: Some("Open the project in the Godot editor".into()),
|
||||
resolve_lazy_variables: false,
|
||||
pinned: None,
|
||||
}),
|
||||
};
|
||||
@@ -2780,53 +2763,6 @@ async fn step_of_one_thread_keeps_the_others_suspended() {
|
||||
assert_eq!(session.suspended.ticket(), ticket + 1);
|
||||
h.manager.step_in_target(id, 7, 1).await.unwrap();
|
||||
assert!(!session.suspended.get());
|
||||
// The UI stays on a thread that is still stopped only when told the step ran one thread.
|
||||
for thread in [7, 8] {
|
||||
let continued =
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Continued { thread_id, .. } if *thread_id == thread)).await;
|
||||
assert!(matches!(continued, DebugEvent::Continued { all_threads_continued: false, .. }), "{continued:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn lazy_variables_are_resolved_when_the_adapter_declares_them_safe() {
|
||||
let h = harness(Script::default());
|
||||
let id = h.start(java_config("launch")).await.unwrap();
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
|
||||
let vars = h.manager.variables(id, 200).await.unwrap();
|
||||
let order = &vars[0];
|
||||
assert_eq!(
|
||||
(order.name.as_str(), order.value.as_str(), order.type_name.as_deref()),
|
||||
("order", "Order@7 \"Order(1)\"", Some("Order"))
|
||||
);
|
||||
assert_eq!((order.variables_reference, order.lazy), (202, false));
|
||||
assert_eq!(order.evaluate_name.as_deref(), Some("order"));
|
||||
assert_eq!((vars[1].name.as_str(), vars[1].lazy), ("n", false));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn lazy_variables_stay_lazy_for_other_adapters() {
|
||||
let h = harness(Script::default());
|
||||
let id = h.start(config()).await.unwrap();
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
|
||||
let vars = h.manager.variables(id, 200).await.unwrap();
|
||||
assert_eq!((vars[0].value.as_str(), vars[0].variables_reference, vars[0].lazy), ("Order@7", 201, true));
|
||||
assert_eq!(requests(&h, "variables").len(), 1, "nothing is computed until asked for");
|
||||
|
||||
let order = h.manager.resolve_variable(id, vars[0].clone()).await.unwrap();
|
||||
assert_eq!((order.name.as_str(), order.value.as_str()), ("order", "Order@7 \"Order(1)\""));
|
||||
assert_eq!((order.variables_reference, order.lazy), (202, false));
|
||||
let n = h.manager.resolve_variable(id, vars[1].clone()).await.unwrap();
|
||||
assert_eq!((n.value.as_str(), requests(&h, "variables").len()), ("2", 2), "only lazy values are computed");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn java_debug_declares_its_lazy_variables_safe_to_resolve() {
|
||||
let languages = LanguageRegistry::load(None).unwrap();
|
||||
for registry in [&languages, &LanguageRegistry::from_configs(Vec::new())] {
|
||||
assert!(adapter::find_config(registry, "java-debug").unwrap().resolve_lazy_variables);
|
||||
assert!(!adapter::find_config(registry, "js-debug").unwrap().resolve_lazy_variables);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
@@ -145,38 +145,30 @@ impl ClickhousePool {
|
||||
let cancel = CancellationToken::new();
|
||||
let initialize = async {
|
||||
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
|
||||
let Some(setting) = rejected_driver_setting(&error) else {
|
||||
if !rejects_driver_setting(&error) {
|
||||
return Err(error);
|
||||
};
|
||||
}
|
||||
if !use_http_session {
|
||||
if setting == "readonly" {
|
||||
return Err(error);
|
||||
}
|
||||
if !source.read_only {
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; enable Read-only for independent queries on a strict read-only server",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Every request still sends readonly=1, regardless of which node answers.
|
||||
pool.0.session.lock().await.strict_read_only = true;
|
||||
pool.execute("SELECT 1", 1, &cancel).await?;
|
||||
} else {
|
||||
// Only rely on the server's write protection after proving strict read-only
|
||||
// in this same named session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// The rejected probe may have opened a session on a different node.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
}
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Retry only the connection probe. Keep relying on the server for write protection
|
||||
// only after verifying strict read-only mode in this same session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// Start the proof in a fresh session: the rejected probe may have left
|
||||
// its id on another replica without applying the configured database.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
// The HTTP database parameter applies to one request. A named session needs
|
||||
@@ -244,7 +236,7 @@ impl ClickhousePool {
|
||||
if !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
|
||||
request = request.query(&[("database", &self.0.database)]);
|
||||
}
|
||||
if self.0.read_only && (session.id.is_none() || !session.strict_read_only) {
|
||||
if self.0.read_only && !session.strict_read_only {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
request
|
||||
@@ -332,7 +324,7 @@ impl ClickhousePool {
|
||||
result
|
||||
}
|
||||
None => {
|
||||
let killed = self.kill(&client, &query_id, &session).await;
|
||||
let killed = self.kill(&client, &query_id).await;
|
||||
match killed {
|
||||
Ok(()) => Err(IdeError::cancelled()),
|
||||
Err(error) => Err(IdeError::new(
|
||||
@@ -344,16 +336,15 @@ impl ClickhousePool {
|
||||
}
|
||||
}
|
||||
|
||||
async fn kill(&self, client: &Client, query_id: &str, session: &Session) -> IdeResult<()> {
|
||||
let mut request = client
|
||||
async fn kill(&self, client: &Client, query_id: &str) -> IdeResult<()> {
|
||||
let response = client
|
||||
.post(self.0.endpoint.clone())
|
||||
.basic_auth(&self.0.user, Some(&self.0.password))
|
||||
.timeout(Duration::from_secs(3));
|
||||
if self.0.read_only && session.id.is_none() {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
let response =
|
||||
request.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")).send().await.map_err(http_error)?;
|
||||
.timeout(Duration::from_secs(3))
|
||||
.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC"))
|
||||
.send()
|
||||
.await
|
||||
.map_err(http_error)?;
|
||||
let status = response.status();
|
||||
let code = response
|
||||
.headers()
|
||||
@@ -560,14 +551,13 @@ fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
|
||||
.map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
|
||||
}
|
||||
|
||||
fn rejected_driver_setting(error: &IdeError) -> Option<&str> {
|
||||
fn rejects_driver_setting(error: &IdeError) -> bool {
|
||||
error
|
||||
.message
|
||||
.split_once(": ")
|
||||
.and_then(|(_, detail)| detail.strip_prefix("Code: 164. DB::Exception: Cannot modify '"))
|
||||
.and_then(|detail| detail.split_once("' setting in readonly mode"))
|
||||
.map(|(name, _)| name)
|
||||
.filter(|&name| {
|
||||
.is_some_and(|(name, _)| {
|
||||
matches!(
|
||||
name,
|
||||
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
|
||||
@@ -963,77 +953,19 @@ mod tests {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn strict_stateless_connections_keep_readonly_on_every_request() {
|
||||
let denied = "Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)";
|
||||
let (port, requests) = server(vec![
|
||||
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", denied),
|
||||
("200 OK", "", ONE),
|
||||
(
|
||||
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
|
||||
for read_only in [false, true] {
|
||||
let (port, requests) = server(vec![(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot execute query in readonly mode. (READONLY)",
|
||||
),
|
||||
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[0]\n[1]\n[2]\n"),
|
||||
])
|
||||
.await;
|
||||
let source = DataSource {
|
||||
database: "fixture_database".into(),
|
||||
read_only: true,
|
||||
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let write = "CREATE TABLE fixture_table (n UInt8) ENGINE=Memory";
|
||||
assert!(pool.execute(write, 1, &cancel).await.unwrap_err().message.contains("Code: 164"));
|
||||
let sql = "SELECT number AS n FROM numbers(3) LIMIT 3";
|
||||
let result = pool.execute(sql, 1, &cancel).await.unwrap();
|
||||
assert_eq!(result.rows, vec![vec![Some("0".into())]]);
|
||||
assert!(result.has_more);
|
||||
let requests = requests.await.unwrap();
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[1].ends_with("SELECT 1"));
|
||||
assert!(requests[2].ends_with(write));
|
||||
assert!(requests[3].ends_with(sql));
|
||||
for (index, request) in requests.iter().enumerate() {
|
||||
let url = request_url(request);
|
||||
for name in ["session_id", "session_check", "session_timeout", "use_http_session"] {
|
||||
assert_eq!(query_value(&url, name), None, "{name}");
|
||||
}
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "database").as_deref(), Some("fixture_database"));
|
||||
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
|
||||
assert_eq!(query_value(&url, "max_result_rows").as_deref(), (index == 0).then_some("2"));
|
||||
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), (index == 0).then_some("break"));
|
||||
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), (index == 0).then_some("1"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_connections_require_readonly_and_only_relax_driver_result_settings() {
|
||||
for (read_only, detail, body) in [
|
||||
(
|
||||
false,
|
||||
"enable Read-only",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
(
|
||||
true,
|
||||
"Cannot modify 'readonly'",
|
||||
"Code: 164. DB::Exception: Cannot modify 'readonly' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
(
|
||||
true,
|
||||
"Cannot modify 'max_threads'",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_threads' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
] {
|
||||
let (port, requests) =
|
||||
server(vec![("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", body)]).await;
|
||||
)])
|
||||
.await;
|
||||
let source =
|
||||
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
|
||||
assert!(error.message.contains(detail), "{}", error.message);
|
||||
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
|
||||
assert!(error.message.contains("use_http_session=false requires per-request"));
|
||||
let requests = requests.await.unwrap();
|
||||
assert_eq!(requests.len(), 1);
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
@@ -1109,7 +1041,7 @@ mod tests {
|
||||
let error = IdeError::invalid(format!(
|
||||
"ClickHouse HTTP 500: Code: {code}. DB::Exception: Cannot modify '{setting}' setting in readonly mode. (READONLY)"
|
||||
));
|
||||
assert_eq!(rejected_driver_setting(&error).is_some(), expected, "{setting}");
|
||||
assert_eq!(rejects_driver_setting(&error), expected, "{setting}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1152,45 +1084,37 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn cancellation_sends_kill_outside_the_busy_session() {
|
||||
for stateless in [false, true] {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let (started, received) = tokio::sync::oneshot::channel();
|
||||
let server = tokio::spawn(async move {
|
||||
let (mut health, _) = listener.accept().await.unwrap();
|
||||
read_request(&mut health).await;
|
||||
reply(&mut health, "200 OK", "", ONE).await;
|
||||
drop(health);
|
||||
let (mut query, _) = listener.accept().await.unwrap();
|
||||
let request = read_request(&mut query).await;
|
||||
started.send(()).unwrap();
|
||||
let (mut kill, _) =
|
||||
tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
|
||||
let kill_request = read_request(&mut kill).await;
|
||||
reply(&mut kill, "200 OK", "", "").await;
|
||||
(request, kill_request)
|
||||
});
|
||||
let source = DataSource {
|
||||
read_only: true,
|
||||
properties: vec![property("use_http_session", if stateless { "false" } else { "true" })],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
|
||||
let cancelled = async {
|
||||
received.await.unwrap();
|
||||
cancel.cancel();
|
||||
};
|
||||
let (result, ()) = tokio::join!(query, cancelled);
|
||||
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
|
||||
let (query, kill) = server.await.unwrap();
|
||||
let query_id = query_value(&request_url(&query), "query_id").unwrap();
|
||||
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
|
||||
let url = request_url(&kill);
|
||||
assert_eq!(query_value(&url, "session_id"), None);
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), stateless.then_some("1"));
|
||||
}
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let (started, received) = tokio::sync::oneshot::channel();
|
||||
let server = tokio::spawn(async move {
|
||||
let (mut health, _) = listener.accept().await.unwrap();
|
||||
read_request(&mut health).await;
|
||||
reply(&mut health, "200 OK", "", ONE).await;
|
||||
drop(health);
|
||||
let (mut query, _) = listener.accept().await.unwrap();
|
||||
let request = read_request(&mut query).await;
|
||||
started.send(()).unwrap();
|
||||
let (mut kill, _) = tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
|
||||
let kill_request = read_request(&mut kill).await;
|
||||
reply(&mut kill, "200 OK", "", "").await;
|
||||
(request, kill_request)
|
||||
});
|
||||
let pool = Pool::connect(&source(port), None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
|
||||
let cancelled = async {
|
||||
received.await.unwrap();
|
||||
cancel.cancel();
|
||||
};
|
||||
let (result, ()) = tokio::join!(query, cancelled);
|
||||
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
|
||||
let (query, kill) = server.await.unwrap();
|
||||
let target = query.lines().next().unwrap().split_whitespace().nth(1).unwrap();
|
||||
let url = Url::parse(&format!("http://localhost{target}")).unwrap();
|
||||
let query_id = url.query_pairs().find(|(k, _)| k == "query_id").unwrap().1.into_owned();
|
||||
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
|
||||
assert!(!kill.contains("session_id="));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
@@ -749,14 +749,6 @@ impl Pool {
|
||||
}
|
||||
|
||||
/// The keep-alive ping (Oracle needs a FROM clause).
|
||||
/// Keep-alive: one cheap round trip on the session.
|
||||
pub async fn ping(&self) -> IdeResult<()> {
|
||||
match self {
|
||||
Pool::Jdbc(p) => p.ping().await,
|
||||
_ => self.rows(self.ping_sql(), 1).await.map(|_| ()),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn ping_sql(&self) -> &'static str {
|
||||
match self {
|
||||
Pool::Oracle(_) => "SELECT 1 FROM DUAL",
|
||||
|
||||
@@ -5,7 +5,6 @@ use crate::{DataSource, DbManager, QueryResult, ResultColumn};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::HashMap;
|
||||
use std::io::{Cursor, Read};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Stdio;
|
||||
@@ -303,9 +302,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(
|
||||
@@ -461,44 +458,6 @@ impl JdbcPool {
|
||||
}
|
||||
|
||||
async fn request(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
|
||||
let result = self.exchange_once(fields, sql, cancel).await;
|
||||
if let Err(e) = &result
|
||||
&& fields.first() != Some(&"open")
|
||||
&& e.kind != ide_core::error::ErrorKind::Cancelled
|
||||
&& !self.is_closed()
|
||||
&& !self.session_valid().await
|
||||
{
|
||||
// The session is gone (a proxy or tunnel dropped the idle TCP connection): close the
|
||||
// pool so the next statement or Connect starts a new one instead of failing forever.
|
||||
self.close().await;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Keep-alive: checks the session (any SQL would be dialect-specific) and closes a dead one.
|
||||
pub(crate) async fn ping(&self) -> IdeResult<()> {
|
||||
if self.session_valid().await {
|
||||
return Ok(());
|
||||
}
|
||||
self.close().await;
|
||||
Err(IdeError::new(ide_core::error::ErrorKind::Io, "JDBC connection was lost"))
|
||||
}
|
||||
|
||||
/// Whether the JDBC session still works, asked after a failed statement.
|
||||
async fn session_valid(&self) -> bool {
|
||||
if self.bridge.lock().await.is_none() {
|
||||
return false;
|
||||
}
|
||||
let cancel = CancellationToken::new();
|
||||
match tokio::time::timeout(Duration::from_secs(10), self.exchange_once(&["valid"], "", &cancel)).await {
|
||||
Ok(Ok(result)) => {
|
||||
result.rows.first().and_then(|row| row.first()).cloned().flatten().as_deref() != Some("false")
|
||||
}
|
||||
Ok(Err(_)) | Err(_) => false,
|
||||
}
|
||||
}
|
||||
|
||||
async fn exchange_once(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
|
||||
let mut slot = tokio::select! {
|
||||
biased;
|
||||
() = cancel.cancelled() => return Err(IdeError::cancelled()),
|
||||
@@ -603,32 +562,14 @@ fn decode(data: &[u8], sql: &str, elapsed_ms: f64) -> IdeResult<QueryResult> {
|
||||
impl DbManager {
|
||||
pub(crate) async fn jdbc_completion(&self, id: &str, pool: &JdbcPool) -> IdeResult<crate::CompletionModel> {
|
||||
let mut tables = vec![];
|
||||
let 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 {
|
||||
pool.metadata(&["schemaColumns", schema]).await.map(schema_columns).unwrap_or_else(|e| {
|
||||
tracing::warn!("JDBC columns of {schema}: {}", e.message);
|
||||
HashMap::new()
|
||||
})
|
||||
} else {
|
||||
HashMap::new()
|
||||
};
|
||||
for table in self.tables(id, schema).await? {
|
||||
let columns = columns.remove(&table.name).unwrap_or_default();
|
||||
column_count += columns.len();
|
||||
tables.push(crate::CompletionTable {
|
||||
schema: schema.clone(),
|
||||
name: table.name,
|
||||
kind: table.kind,
|
||||
columns,
|
||||
columns: vec![],
|
||||
});
|
||||
if tables.len() >= crate::MAX_META_ROWS {
|
||||
break;
|
||||
@@ -653,49 +594,10 @@ impl DbManager {
|
||||
}
|
||||
}
|
||||
|
||||
/// The bridge's `schemaColumns` rows (table, name, type, nullable, default) by table.
|
||||
fn schema_columns(rows: Vec<Vec<Option<String>>>) -> HashMap<String, Vec<crate::CompletionColumn>> {
|
||||
let mut by_table: HashMap<String, Vec<crate::CompletionColumn>> = HashMap::new();
|
||||
for row in rows {
|
||||
let mut it = row.into_iter();
|
||||
let (Some(Some(table)), Some(Some(name))) = (it.next(), it.next()) else { continue };
|
||||
let data_type = it.next().flatten().unwrap_or_default();
|
||||
let nullable = it.next().flatten().as_deref() != Some("0");
|
||||
let has_default = it.next().flatten().is_some();
|
||||
by_table.entry(table).or_default().push(crate::CompletionColumn {
|
||||
name,
|
||||
data_type,
|
||||
nullable,
|
||||
primary_key: false,
|
||||
has_default,
|
||||
});
|
||||
}
|
||||
by_table
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn schema_columns_group_by_table() {
|
||||
let row = |t: &str, n: &str, null: &str, def: Option<&str>| {
|
||||
vec![Some(t.into()), Some(n.into()), Some("INT".into()), Some(null.into()), def.map(Into::into)]
|
||||
};
|
||||
let by_table = schema_columns(vec![
|
||||
row("orders", "id", "0", None),
|
||||
row("orders", "note", "1", Some("'none'")),
|
||||
row("items", "sku", "1", None),
|
||||
vec![None, Some("orphan".into())],
|
||||
]);
|
||||
let orders = &by_table["orders"];
|
||||
assert_eq!(orders.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["id", "note"]);
|
||||
assert_eq!((orders[0].nullable, orders[0].has_default), (false, false));
|
||||
assert_eq!((orders[1].nullable, orders[1].has_default), (true, true));
|
||||
assert_eq!(by_table["items"].len(), 1);
|
||||
assert_eq!(by_table.len(), 2);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn frame_codec_checks_both_16_mib_boundaries() {
|
||||
assert_eq!(encode(7, &["a"]).unwrap(), [0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, 1, b'a']);
|
||||
|
||||
@@ -379,8 +379,8 @@ pub(crate) fn keep_alive(pool: &Arc<Pool>, every: Duration) {
|
||||
loop {
|
||||
tick.tick().await;
|
||||
let Some(p) = pool.upgrade().filter(|p| !p.is_closed()) else { break };
|
||||
if let Err(e) = p.ping().await {
|
||||
tracing::info!("keep-alive: {}", e.message);
|
||||
if let Err(e) = p.rows(p.ping_sql(), 1).await {
|
||||
tracing::debug!("keep-alive: {}", e.message);
|
||||
}
|
||||
}
|
||||
});
|
||||
@@ -847,12 +847,12 @@ impl DbManager {
|
||||
}
|
||||
|
||||
pub fn is_connected(&self, id: &str) -> bool {
|
||||
self.pools.lock().get(id).is_some_and(|p| !p.is_closed())
|
||||
self.pools.lock().contains_key(id)
|
||||
}
|
||||
|
||||
/// Connected targets (data source ids, `<id>:<database>`).
|
||||
pub fn connected(&self) -> Vec<String> {
|
||||
self.pools.lock().iter().filter(|(_, p)| !p.is_closed()).map(|(id, _)| id.clone()).collect()
|
||||
self.pools.lock().keys().cloned().collect()
|
||||
}
|
||||
|
||||
/// The pool of target `id`, connecting first if needed.
|
||||
@@ -862,13 +862,8 @@ impl DbManager {
|
||||
if self.tunnels.lock().get(source_id).is_some_and(|t| t.is_closed()) {
|
||||
self.disconnect_source(source_id).await;
|
||||
}
|
||||
let cached = self.pools.lock().get(id).cloned();
|
||||
if let Some(p) = cached {
|
||||
if !p.is_closed() {
|
||||
return Ok(p);
|
||||
}
|
||||
// The connection broke (a custom JDBC session whose TCP connection was dropped): reconnect.
|
||||
self.disconnect(id).await;
|
||||
if let Some(p) = self.pools.lock().get(id) {
|
||||
return Ok(p.clone());
|
||||
}
|
||||
let source = self.source(id)?;
|
||||
let password = self.password(&source).await;
|
||||
@@ -922,7 +917,7 @@ impl DbManager {
|
||||
|
||||
/// Disconnects every database of data source `id`.
|
||||
pub async fn disconnect_source(&self, id: &str) {
|
||||
let targets: Vec<String> = self.pools.lock().keys().filter(|t| split_target(t).0 == id).cloned().collect();
|
||||
let targets: Vec<String> = self.connected().into_iter().filter(|t| split_target(t).0 == id).collect();
|
||||
for t in targets {
|
||||
self.disconnect(&t).await;
|
||||
}
|
||||
|
||||
@@ -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"));
|
||||
}
|
||||
}
|
||||
@@ -90,10 +90,7 @@ async fn duckdb_custom_driver_through_database_manager() -> IdeResult<()> {
|
||||
assert!(result.has_more);
|
||||
assert_eq!(result.rows, vec![vec![Some("1".into()), None]]);
|
||||
assert_eq!(result.columns[1].name, "label");
|
||||
let completion = db.completion("test").await?;
|
||||
assert_eq!(completion.default_schema, "main");
|
||||
let items = completion.tables.iter().find(|t| t.schema == "main" && t.name == "items").expect("items");
|
||||
assert_eq!(items.columns.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["id", "label"]);
|
||||
assert_eq!(db.completion("test").await?.default_schema, "main");
|
||||
db.execute("test", "create temporary table session_marker as select 42 as id", 1, &c).await?;
|
||||
let stop = CancellationToken::new();
|
||||
let (cancelled, ()) =
|
||||
@@ -210,46 +207,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;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "requires JDBC_FIXTURE_JAR (java/jdbc-bridge/build.py --test --out fixture.jar) and Java 17+"]
|
||||
async fn a_lost_session_reconnects_on_the_next_statement() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir()?;
|
||||
let db = manager(tmp.path());
|
||||
db.save_jdbc_driver(DbJdbcDriver {
|
||||
id: "fixture".into(),
|
||||
name: "Fixture".into(),
|
||||
jars: vec![std::env::var("JDBC_FIXTURE_JAR").unwrap()],
|
||||
class_name: "ai.openidea.jdbc.SelfTest$Fixture".into(),
|
||||
url_template: String::new(),
|
||||
})?;
|
||||
let source = DataSource {
|
||||
id: "test".into(),
|
||||
name: "Fixture".into(),
|
||||
driver: DbDriver::Jdbc,
|
||||
global: true,
|
||||
jdbc_driver: "fixture".into(),
|
||||
url: "jdbc:fixture:".into(),
|
||||
..Default::default()
|
||||
};
|
||||
db.save_sources(vec![source]).await?;
|
||||
let cancel = CancellationToken::new();
|
||||
db.execute("test", "first", 1, &cancel).await?;
|
||||
// The fixture's session reports itself invalid after "drop", like a connection a proxy reset.
|
||||
assert!(db.execute("test", "drop", 1, &cancel).await.unwrap_err().message.contains("connection reset"));
|
||||
assert!(!db.is_connected("test"), "a lost session is no longer listed as connected");
|
||||
assert_eq!(db.execute("test", "after reconnect", 1, &cancel).await?.affected, Some(1.0));
|
||||
assert!(db.is_connected("test"));
|
||||
assert_eq!(db.execute("test", "after reconnect", 1, &normal).await?.affected, Some(1.0));
|
||||
db.disconnect("test").await;
|
||||
Ok(())
|
||||
}
|
||||
@@ -7,10 +7,9 @@
|
||||
|
||||
use crate::{
|
||||
COMPOSE_DIR, COMPOSE_FILES, COMPOSE_PROJECT, COMPOSE_SERVICE, ContainerOp, DockerAvailability, DockerContainer,
|
||||
DockerEndpoint, DockerImage, DockerImageLayer, DockerLogLine, DockerNetwork, DockerObject, DockerProcessList,
|
||||
DockerSnapshot, DockerVolume, split_csv,
|
||||
DockerEndpoint, DockerImage, DockerNetwork, DockerObject, DockerSnapshot, DockerVolume, split_csv,
|
||||
};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use serde::Deserialize;
|
||||
use std::collections::BTreeMap;
|
||||
use std::io::{Read, Write};
|
||||
@@ -194,15 +193,9 @@ fn request(addr: &Address, method: &str, path: &str, timeout: Duration) -> IdeRe
|
||||
read_response(&mut conn)
|
||||
}
|
||||
|
||||
/// A response's status line and body framing.
|
||||
struct Head {
|
||||
status: u16,
|
||||
chunked: bool,
|
||||
length: Option<usize>,
|
||||
}
|
||||
|
||||
/// Reads an HTTP/1.1 response head until `\r\n\r\n`.
|
||||
fn read_head(stream: &mut impl Read) -> IdeResult<Head> {
|
||||
/// Reads an HTTP/1.1 response: head until `\r\n\r\n`, then the body per its
|
||||
/// framing (chunked, `Content-Length`, or until the connection closes).
|
||||
fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
|
||||
let mut head: Vec<u8> = Vec::new();
|
||||
let mut byte = [0u8; 1];
|
||||
loop {
|
||||
@@ -235,27 +228,16 @@ fn read_head(stream: &mut impl Read) -> IdeResult<Head> {
|
||||
length = value.parse().ok();
|
||||
}
|
||||
}
|
||||
Ok(Head { status, chunked, length })
|
||||
}
|
||||
|
||||
/// Reads an HTTP/1.1 response: its head, then the body per its framing
|
||||
/// (chunked, `Content-Length`, or until the connection closes).
|
||||
fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
|
||||
let head = read_head(stream)?;
|
||||
let body = read_body(stream, &head)?;
|
||||
Ok(Response { status: head.status, body })
|
||||
}
|
||||
|
||||
fn read_body(stream: &mut impl Read, head: &Head) -> IdeResult<Vec<u8>> {
|
||||
Ok(if head.chunked {
|
||||
let body = if chunked {
|
||||
read_chunked(stream)?
|
||||
} else if let Some(n) = head.length {
|
||||
} else if let Some(n) = length {
|
||||
read_exact_n(stream, n)?
|
||||
} else {
|
||||
let mut body = Vec::new();
|
||||
stream.read_to_end(&mut body)?;
|
||||
body
|
||||
})
|
||||
};
|
||||
Ok(Response { status, body })
|
||||
}
|
||||
|
||||
/// Reads one `\n`-terminated line (returned without it).
|
||||
@@ -500,292 +482,6 @@ pub(crate) fn inspect(
|
||||
})())
|
||||
}
|
||||
|
||||
/// The processes running in a container (`docker top`).
|
||||
pub(crate) fn container_top(ep: &DockerEndpoint, id: &str, timeout: Duration) -> Option<IdeResult<DockerProcessList>> {
|
||||
let addr = address(ep)?;
|
||||
Some((|| {
|
||||
let body = check(request(&addr, "GET", &format!("/containers/{}/top", path_segment(id)), timeout)?)?;
|
||||
serde_json::from_str::<ApiTop>(&body)
|
||||
.map(|t| DockerProcessList { titles: t.titles, processes: t.processes })
|
||||
.map_err(|e| IdeError::internal(format!("the Docker daemon's process list is not JSON: {e}")))
|
||||
})())
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiTop {
|
||||
titles: Vec<String>,
|
||||
processes: Vec<Vec<String>>,
|
||||
}
|
||||
|
||||
/// An image's layers, newest first (`docker image history`).
|
||||
pub(crate) fn image_history(
|
||||
ep: &DockerEndpoint,
|
||||
id: &str,
|
||||
timeout: Duration,
|
||||
) -> Option<IdeResult<Vec<DockerImageLayer>>> {
|
||||
let addr = address(ep)?;
|
||||
Some((|| {
|
||||
let body = check(request(&addr, "GET", &format!("/images/{}/history", path_segment(id)), timeout)?)?;
|
||||
let layers = serde_json::from_str::<Vec<ApiLayer>>(&body)
|
||||
.map_err(|e| IdeError::internal(format!("the Docker daemon's image history is not JSON: {e}")))?;
|
||||
Ok(map_layers(layers, unix_now()))
|
||||
})())
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiLayer {
|
||||
id: String,
|
||||
created: i64,
|
||||
created_by: String,
|
||||
size: i64,
|
||||
comment: String,
|
||||
}
|
||||
|
||||
fn map_layers(layers: Vec<ApiLayer>, now: i64) -> Vec<DockerImageLayer> {
|
||||
layers
|
||||
.into_iter()
|
||||
.map(|l| DockerImageLayer {
|
||||
id: l.id,
|
||||
created_by: l.created_by,
|
||||
size: human_size(l.size),
|
||||
created_since: human_duration((now - l.created).max(0)),
|
||||
created_at: unix_utc(l.created),
|
||||
comment: l.comment,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn unix_now() -> i64 {
|
||||
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs() as i64).unwrap_or(0)
|
||||
}
|
||||
|
||||
/// How often a log stream that has nothing to read checks for cancellation.
|
||||
const LOG_POLL: Duration = Duration::from_millis(200);
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiContainerInspect {
|
||||
config: ApiContainerConfig,
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiContainerConfig {
|
||||
tty: bool,
|
||||
}
|
||||
|
||||
/// Streams a container's logs (`tail` last lines, then follows while `follow`)
|
||||
/// from `ep`'s daemon until they end or `cancel` fires.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(crate) fn logs(
|
||||
ep: &DockerEndpoint,
|
||||
id: &str,
|
||||
tail: u32,
|
||||
follow: bool,
|
||||
timestamps: bool,
|
||||
timeout: Duration,
|
||||
cancel: &CancellationToken,
|
||||
on_line: &dyn Fn(DockerLogLine),
|
||||
) -> Option<IdeResult<()>> {
|
||||
let addr = address(ep)?;
|
||||
Some((|| {
|
||||
// A TTY container's log is one raw stream; otherwise it is framed per stream.
|
||||
let body = check(request(&addr, "GET", &format!("/containers/{}/json", path_segment(id)), timeout)?)?;
|
||||
let tty = serde_json::from_str::<ApiContainerInspect>(&body).map(|c| c.config.tty).unwrap_or(false);
|
||||
let path = format!(
|
||||
"/containers/{}/logs?stdout=1&stderr=1&tail={tail}&follow={}×tamps={}",
|
||||
path_segment(id),
|
||||
u8::from(follow),
|
||||
u8::from(timestamps),
|
||||
);
|
||||
let mut conn = Conn::connect(&addr, timeout)?;
|
||||
conn.write_all(
|
||||
format!("GET {path} HTTP/1.1\r\nHost: docker\r\nUser-Agent: openidea\r\nConnection: close\r\n\r\n")
|
||||
.as_bytes(),
|
||||
)?;
|
||||
let head = read_head(&mut conn)?;
|
||||
if !(200..300).contains(&head.status) {
|
||||
let body = read_body(&mut conn, &head)?;
|
||||
check(Response { status: head.status, body })?;
|
||||
}
|
||||
conn.set_timeouts(LOG_POLL);
|
||||
let mut decoder = LogDecoder::new(&head, tty);
|
||||
let mut buf = [0u8; 8192];
|
||||
while !decoder.done() {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
match conn.read(&mut buf) {
|
||||
Ok(0) => break,
|
||||
Ok(n) => decoder.feed(&buf[..n], &mut |line| on_line(line))?,
|
||||
Err(e)
|
||||
if matches!(
|
||||
e.kind(),
|
||||
std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut | std::io::ErrorKind::Interrupted
|
||||
) => {}
|
||||
Err(e) => return Err(e.into()),
|
||||
}
|
||||
}
|
||||
decoder.finish(&mut |line| on_line(line));
|
||||
Ok(())
|
||||
})())
|
||||
}
|
||||
|
||||
/// Turns a log response body, as it arrives, into lines: undoes the chunked
|
||||
/// transfer encoding, then the per-stream frames (8-byte header: stream, 3 zero
|
||||
/// bytes, big-endian length) unless the container has a TTY.
|
||||
struct LogDecoder {
|
||||
body: BodyFraming,
|
||||
tty: bool,
|
||||
header: Vec<u8>,
|
||||
frame_left: usize,
|
||||
frame_stderr: bool,
|
||||
/// Partial lines of stdout and stderr.
|
||||
partial: [Vec<u8>; 2],
|
||||
}
|
||||
|
||||
enum BodyFraming {
|
||||
Chunked { state: ChunkState, line: Vec<u8> },
|
||||
Length(usize),
|
||||
Close,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
enum ChunkState {
|
||||
Size,
|
||||
Data(usize),
|
||||
DataEnd,
|
||||
Trailer,
|
||||
Done,
|
||||
}
|
||||
|
||||
impl LogDecoder {
|
||||
fn new(head: &Head, tty: bool) -> Self {
|
||||
let body = if head.chunked {
|
||||
BodyFraming::Chunked { state: ChunkState::Size, line: Vec::new() }
|
||||
} else if let Some(n) = head.length {
|
||||
BodyFraming::Length(n)
|
||||
} else {
|
||||
BodyFraming::Close
|
||||
};
|
||||
Self { body, tty, header: Vec::new(), frame_left: 0, frame_stderr: false, partial: [Vec::new(), Vec::new()] }
|
||||
}
|
||||
|
||||
fn done(&self) -> bool {
|
||||
matches!(self.body, BodyFraming::Chunked { state: ChunkState::Done, .. } | BodyFraming::Length(0))
|
||||
}
|
||||
|
||||
fn feed(&mut self, mut bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) -> IdeResult<()> {
|
||||
let mut payload = Vec::new();
|
||||
match &mut self.body {
|
||||
BodyFraming::Close => payload.extend_from_slice(bytes),
|
||||
BodyFraming::Length(left) => {
|
||||
let take = (*left).min(bytes.len());
|
||||
payload.extend_from_slice(&bytes[..take]);
|
||||
*left -= take;
|
||||
}
|
||||
BodyFraming::Chunked { state, line } => {
|
||||
while !bytes.is_empty() {
|
||||
match *state {
|
||||
ChunkState::Done => break,
|
||||
ChunkState::Data(n) => {
|
||||
let take = n.min(bytes.len());
|
||||
payload.extend_from_slice(&bytes[..take]);
|
||||
bytes = &bytes[take..];
|
||||
*state = if take == n { ChunkState::DataEnd } else { ChunkState::Data(n - take) };
|
||||
}
|
||||
_ => {
|
||||
let b = bytes[0];
|
||||
bytes = &bytes[1..];
|
||||
if b != b'\n' {
|
||||
if b != b'\r' {
|
||||
line.push(b);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let text = String::from_utf8_lossy(line).into_owned();
|
||||
line.clear();
|
||||
*state = match *state {
|
||||
ChunkState::Size => {
|
||||
let size = text.split(';').next().unwrap_or_default().trim();
|
||||
match usize::from_str_radix(size, 16) {
|
||||
Ok(0) => ChunkState::Trailer,
|
||||
Ok(n) => ChunkState::Data(n),
|
||||
Err(_) => {
|
||||
return Err(IdeError::internal(
|
||||
"the Docker daemon answered with a malformed chunked response",
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
ChunkState::DataEnd => ChunkState::Size,
|
||||
_ if text.is_empty() => ChunkState::Done,
|
||||
other => other,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
self.frames(&payload, emit);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn frames(&mut self, mut bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) {
|
||||
if self.tty {
|
||||
self.lines(false, bytes, emit);
|
||||
return;
|
||||
}
|
||||
while !bytes.is_empty() {
|
||||
if self.frame_left == 0 {
|
||||
let take = (8 - self.header.len()).min(bytes.len());
|
||||
self.header.extend_from_slice(&bytes[..take]);
|
||||
bytes = &bytes[take..];
|
||||
if self.header.len() == 8 {
|
||||
self.frame_stderr = self.header[0] == 2;
|
||||
self.frame_left =
|
||||
u32::from_be_bytes([self.header[4], self.header[5], self.header[6], self.header[7]]) as usize;
|
||||
self.header.clear();
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let take = self.frame_left.min(bytes.len());
|
||||
self.lines(self.frame_stderr, &bytes[..take], emit);
|
||||
self.frame_left -= take;
|
||||
bytes = &bytes[take..];
|
||||
}
|
||||
}
|
||||
|
||||
fn lines(&mut self, stderr: bool, bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) {
|
||||
let partial = &mut self.partial[usize::from(stderr)];
|
||||
for &b in bytes {
|
||||
if b == b'\n' {
|
||||
emit(DockerLogLine { stderr, text: line_text(partial) });
|
||||
partial.clear();
|
||||
} else {
|
||||
partial.push(b);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Emits the last lines that ended without a newline.
|
||||
fn finish(&mut self, emit: &mut dyn FnMut(DockerLogLine)) {
|
||||
for stderr in [false, true] {
|
||||
let partial = &mut self.partial[usize::from(stderr)];
|
||||
if !partial.is_empty() {
|
||||
emit(DockerLogLine { stderr, text: line_text(partial) });
|
||||
partial.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn line_text(bytes: &[u8]) -> String {
|
||||
String::from_utf8_lossy(bytes.strip_suffix(b"\r").unwrap_or(bytes)).into_owned()
|
||||
}
|
||||
|
||||
/// One URL path segment, percent-encoded so an id cannot change the path.
|
||||
fn path_segment(id: &str) -> String {
|
||||
let mut out = String::with_capacity(id.len());
|
||||
@@ -1121,75 +817,6 @@ mod tests {
|
||||
assert!(read_response(&mut &garbage[..]).is_err());
|
||||
}
|
||||
|
||||
/// Feeds `body` one byte at a time, as a slow connection delivers it.
|
||||
fn decode(head: Head, tty: bool, body: &[u8]) -> (Vec<(bool, String)>, bool) {
|
||||
let mut lines = Vec::new();
|
||||
let mut decoder = LogDecoder::new(&head, tty);
|
||||
for b in body {
|
||||
decoder.feed(std::slice::from_ref(b), &mut |l| lines.push((l.stderr, l.text))).unwrap();
|
||||
}
|
||||
let done = decoder.done();
|
||||
decoder.finish(&mut |l| lines.push((l.stderr, l.text)));
|
||||
(lines, done)
|
||||
}
|
||||
|
||||
fn frame(stream: u8, text: &str) -> Vec<u8> {
|
||||
let mut f = vec![stream, 0, 0, 0];
|
||||
f.extend((text.len() as u32).to_be_bytes());
|
||||
f.extend(text.as_bytes());
|
||||
f
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn engine_image_history_reads_like_the_cli() {
|
||||
let layers: Vec<ApiLayer> = serde_json::from_str(
|
||||
r#"[{"Id":"sha256:abc","Created":1000,"CreatedBy":"CMD [\"python3\"]","Size":20500,"Comment":"buildkit","Tags":["py:3"]},
|
||||
{"Id":"<missing>","Created":940,"CreatedBy":"RUN x","Size":0,"Comment":""}]"#,
|
||||
)
|
||||
.unwrap();
|
||||
let rows = map_layers(layers, 1000 + 2 * 7 * 86_400);
|
||||
assert_eq!(
|
||||
rows.iter().map(|l| (l.id.as_str(), l.size.as_str(), l.created_since.as_str())).collect::<Vec<_>>(),
|
||||
[("sha256:abc", "20.5kB", "2 weeks ago"), ("<missing>", "0B", "2 weeks ago")]
|
||||
);
|
||||
assert_eq!(rows[0].created_by, "CMD [\"python3\"]");
|
||||
let top: ApiTop = serde_json::from_str(r#"{"Titles":["PID","CMD"],"Processes":[["1","sh"]]}"#).unwrap();
|
||||
assert_eq!(
|
||||
(top.titles, top.processes),
|
||||
(vec!["PID".to_owned(), "CMD".to_owned()], vec![vec!["1".to_owned(), "sh".to_owned()]])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn container_logs_split_into_stream_lines_across_chunks_and_frames() {
|
||||
// Frames split mid-line, a CRLF line, and a stderr line between stdout parts.
|
||||
let mut framed = frame(1, "tick 1\r\ntick");
|
||||
framed.extend(frame(2, "oops\n"));
|
||||
framed.extend(frame(1, " 2\nlast"));
|
||||
let mut chunked = Vec::new();
|
||||
for part in framed.chunks(7) {
|
||||
chunked.extend(format!("{:x}\r\n", part.len()).as_bytes());
|
||||
chunked.extend(part);
|
||||
chunked.extend(b"\r\n");
|
||||
}
|
||||
chunked.extend(b"0\r\n\r\n");
|
||||
let (lines, done) = decode(Head { status: 200, chunked: true, length: None }, false, &chunked);
|
||||
assert!(done);
|
||||
let expected = [(false, "tick 1"), (true, "oops"), (false, "tick 2"), (false, "last")];
|
||||
assert_eq!(lines, expected.map(|(e, t)| (e, t.to_owned())));
|
||||
|
||||
// A TTY container's log is one raw stream; the body may end with the connection.
|
||||
let (lines, done) = decode(Head { status: 200, chunked: false, length: None }, true, b"a\r\nb\n");
|
||||
assert!(!done);
|
||||
assert_eq!(lines, [(false, "a".to_owned()), (false, "b".to_owned())]);
|
||||
|
||||
// A Content-Length body ends after its length.
|
||||
let body = frame(1, "one\n");
|
||||
let (lines, done) = decode(Head { status: 200, chunked: false, length: Some(body.len()) }, false, &body);
|
||||
assert!(done);
|
||||
assert_eq!(lines, [(false, "one".to_owned())]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn daemon_errors_carry_their_message() {
|
||||
let resp = Response { status: 404, body: br#"{"message":"No such container: missing"}"#.to_vec() };
|
||||
|
||||
@@ -287,11 +287,6 @@ fn check_id(id: &str) -> IdeResult<&str> {
|
||||
/// `docker image history --no-trunc --format '{{json .}}'` of one image.
|
||||
pub fn image_history(ep: &DockerEndpoint, id: &str) -> IdeResult<Vec<DockerImageLayer>> {
|
||||
let id = check_id(id)?;
|
||||
if docker_executable().is_none()
|
||||
&& let Some(layers) = engine::image_history(ep, id, QUICK)
|
||||
{
|
||||
return layers;
|
||||
}
|
||||
let out = run(ep, &["image", "history", "--no-trunc", "--format", "{{json .}}", id], QUICK)?;
|
||||
Ok(parse_image_history(&out))
|
||||
}
|
||||
@@ -299,11 +294,6 @@ pub fn image_history(ep: &DockerEndpoint, id: &str) -> IdeResult<Vec<DockerImage
|
||||
/// `docker top <id>` of a running container.
|
||||
pub fn container_top(ep: &DockerEndpoint, id: &str) -> IdeResult<DockerProcessList> {
|
||||
let id = check_id(id)?;
|
||||
if docker_executable().is_none()
|
||||
&& let Some(processes) = engine::container_top(ep, id, QUICK)
|
||||
{
|
||||
return processes;
|
||||
}
|
||||
let out = run(ep, &["top", id], QUICK)?;
|
||||
Ok(parse_container_top(&out))
|
||||
}
|
||||
@@ -326,11 +316,6 @@ pub fn logs(
|
||||
cancel: &CancellationToken,
|
||||
on_line: &dyn Fn(DockerLogLine),
|
||||
) -> IdeResult<()> {
|
||||
if docker_executable().is_none()
|
||||
&& let Some(streamed) = engine::logs(ep, id, tail, follow, timestamps, QUICK, cancel, on_line)
|
||||
{
|
||||
return streamed;
|
||||
}
|
||||
let tail = tail.to_string();
|
||||
let mut args = vec!["logs", "--tail", &tail];
|
||||
if follow {
|
||||
|
||||
@@ -1,54 +0,0 @@
|
||||
[package]
|
||||
name = "ide-drag-out"
|
||||
description = "OS file drags out of an app window, so file managers and transfer clients copy the files: GTK on Linux, OLE on Windows, AppKit on macOS"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[dependencies]
|
||||
|
||||
[target.'cfg(target_os = "linux")'.dependencies]
|
||||
gtk = "0.18"
|
||||
|
||||
[target.'cfg(any(windows, target_os = "macos"))'.dependencies]
|
||||
raw-window-handle = "0.6"
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows = { version = "0.62", features = [
|
||||
"Win32_Foundation",
|
||||
"Win32_Graphics_Gdi",
|
||||
"Win32_System_Com",
|
||||
"Win32_System_Com_StructuredStorage",
|
||||
"Win32_System_Memory",
|
||||
"Win32_System_Ole",
|
||||
"Win32_System_SystemServices",
|
||||
"Win32_UI_Shell",
|
||||
"Win32_UI_Shell_Common",
|
||||
] }
|
||||
# `#[implement]` expands to paths into `windows_core`.
|
||||
windows-core = "0.62"
|
||||
|
||||
[target.'cfg(target_os = "macos")'.dependencies]
|
||||
objc2 = { version = "0.6", default-features = false, features = ["std"] }
|
||||
objc2-foundation = { version = "0.3", default-features = false, features = ["std", "NSArray", "NSGeometry", "NSObject", "NSString", "NSURL"] }
|
||||
objc2-app-kit = { version = "0.3", default-features = false, features = [
|
||||
"std",
|
||||
"objc2-core-foundation",
|
||||
"NSApplication",
|
||||
"NSDragging",
|
||||
"NSDraggingItem",
|
||||
"NSDraggingSession",
|
||||
"NSEvent",
|
||||
"NSGraphics",
|
||||
"NSGraphicsContext",
|
||||
"NSImage",
|
||||
"NSPasteboard",
|
||||
"NSPasteboardItem",
|
||||
"NSResponder",
|
||||
"NSView",
|
||||
"NSWindow",
|
||||
"NSWorkspace",
|
||||
] }
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile.workspace = true
|
||||
@@ -1,122 +0,0 @@
|
||||
//! macOS: an AppKit dragging session with one pasteboard item per path, each a file URL.
|
||||
|
||||
use super::Outcome;
|
||||
use objc2::rc::Retained;
|
||||
use objc2::runtime::ProtocolObject;
|
||||
use objc2::{AnyThread, DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send};
|
||||
use objc2_app_kit::{
|
||||
NSApplication, NSDragOperation, NSDraggingContext, NSDraggingItem, NSDraggingSession, NSDraggingSource, NSEvent,
|
||||
NSEventModifierFlags, NSEventType, NSPasteboardItem, NSPasteboardTypeFileURL, NSView, NSWorkspace,
|
||||
};
|
||||
use objc2_foundation::{NSArray, NSObject, NSObjectProtocol, NSPoint, NSRect, NSSize, NSString, NSURL};
|
||||
use raw_window_handle::{HasWindowHandle, RawWindowHandle};
|
||||
use std::cell::Cell;
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// The size of each file's icon under the pointer, in points.
|
||||
const ICON_SIZE: f64 = 32.0;
|
||||
|
||||
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`, each shown with its
|
||||
/// Finder icon; `done` runs on the main thread when the drag ends.
|
||||
pub fn start<W: HasWindowHandle>(
|
||||
window: &W,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
let mtm = MainThreadMarker::new().ok_or_else(|| io::Error::other("a drag starts on the main thread"))?;
|
||||
let RawWindowHandle::AppKit(handle) =
|
||||
window.window_handle().map_err(|error| io::Error::other(error.to_string()))?.as_raw()
|
||||
else {
|
||||
return Err(io::Error::other("not an AppKit window"));
|
||||
};
|
||||
// SAFETY: the handle names this window's view, alive while `window` is borrowed.
|
||||
let view = unsafe { handle.ns_view.cast::<NSView>().as_ref() };
|
||||
let window = view.window().ok_or_else(|| io::Error::other("the view has no window"))?;
|
||||
let content = window.contentView().ok_or_else(|| io::Error::other("the window has no content view"))?;
|
||||
// In window coordinates, which are the content view's.
|
||||
let pointer = window.mouseLocationOutsideOfEventStream();
|
||||
let frame = NSRect::new(
|
||||
NSPoint::new(pointer.x - ICON_SIZE / 2.0, pointer.y - ICON_SIZE / 2.0),
|
||||
NSSize::new(ICON_SIZE, ICON_SIZE),
|
||||
);
|
||||
|
||||
let workspace = NSWorkspace::sharedWorkspace();
|
||||
let mut items = Vec::with_capacity(paths.len());
|
||||
for path in &paths {
|
||||
let path = NSString::from_str(&path.to_string_lossy());
|
||||
let url = NSURL::fileURLWithPath(&path)
|
||||
.absoluteString()
|
||||
.ok_or_else(|| io::Error::other(format!("not a file URL: {path}")))?;
|
||||
let item = NSPasteboardItem::new();
|
||||
if !item.setString_forType(&url, unsafe { NSPasteboardTypeFileURL }) {
|
||||
return Err(io::Error::other(format!("cannot put {path} on the pasteboard")));
|
||||
}
|
||||
let drag_item =
|
||||
NSDraggingItem::initWithPasteboardWriter(NSDraggingItem::alloc(), ProtocolObject::from_ref(&*item));
|
||||
let icon = workspace.iconForFile(&path);
|
||||
unsafe { drag_item.setDraggingFrame_contents(frame, Some(&icon)) };
|
||||
items.push(drag_item);
|
||||
}
|
||||
|
||||
// The session starts from a drag event at the pointer: the web view's own mouse events
|
||||
// went to WebKit, and the current event may be a later one.
|
||||
let timestamp = NSApplication::sharedApplication(mtm).currentEvent().map_or(0.0, |event| event.timestamp());
|
||||
let event = NSEvent::mouseEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_clickCount_pressure(
|
||||
NSEventType::LeftMouseDragged,
|
||||
pointer,
|
||||
NSEventModifierFlags::empty(),
|
||||
timestamp,
|
||||
window.windowNumber(),
|
||||
None,
|
||||
0,
|
||||
1,
|
||||
1.0,
|
||||
)
|
||||
.ok_or_else(|| io::Error::other("cannot make the drag event"))?;
|
||||
let source = DragSource::new(Box::new(done), mtm);
|
||||
content.beginDraggingSessionWithItems_event_source(
|
||||
&NSArray::from_retained_slice(&items),
|
||||
&event,
|
||||
ProtocolObject::from_ref(&*source),
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
type Done = Box<dyn FnOnce(Outcome)>;
|
||||
|
||||
struct Ivars {
|
||||
done: Cell<Option<Done>>,
|
||||
}
|
||||
|
||||
define_class!(
|
||||
#[unsafe(super(NSObject))]
|
||||
#[thread_kind = MainThreadOnly]
|
||||
#[name = "OpenIdeaDragOutSource"]
|
||||
#[ivars = Ivars]
|
||||
struct DragSource;
|
||||
|
||||
unsafe impl NSObjectProtocol for DragSource {}
|
||||
|
||||
unsafe impl NSDraggingSource for DragSource {
|
||||
#[unsafe(method(draggingSession:sourceOperationMaskForDraggingContext:))]
|
||||
fn operation_mask(&self, session: &NSDraggingSession, _context: NSDraggingContext) -> NSDragOperation {
|
||||
session.setAnimatesToStartingPositionsOnCancelOrFail(true);
|
||||
NSDragOperation::Copy
|
||||
}
|
||||
|
||||
#[unsafe(method(draggingSession:endedAtPoint:operation:))]
|
||||
fn ended(&self, _session: &NSDraggingSession, _point: NSPoint, operation: NSDragOperation) {
|
||||
if let Some(done) = self.ivars().done.take() {
|
||||
done(if operation == NSDragOperation::None { Outcome::Cancelled } else { Outcome::Dropped });
|
||||
}
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
impl DragSource {
|
||||
fn new(done: Done, mtm: MainThreadMarker) -> Retained<Self> {
|
||||
let this = Self::alloc(mtm).set_ivars(Ivars { done: Cell::new(Some(done)) });
|
||||
unsafe { msg_send![super(this), init] }
|
||||
}
|
||||
}
|
||||
@@ -1,190 +0,0 @@
|
||||
//! OS file drags out of an app window: the app the files are dropped on (Explorer,
|
||||
//! Finder, a file manager, an SFTP client such as Xftp) copies them, as when they are
|
||||
//! dragged from IDEA's Project view (#2867).
|
||||
//!
|
||||
//! Linux starts a GTK drag offering `text/uri-list`, Windows an OLE `DoDragDrop` of a
|
||||
//! `CF_HDROP` data object, macOS an AppKit dragging session of file URLs. A drag is
|
||||
//! always a copy, never a move, so no target can take project files away.
|
||||
//!
|
||||
//! [`start`] runs on the UI thread while the primary button is still held. It returns
|
||||
//! once the drag has begun (Linux, macOS) or ended (Windows); `done` gets the outcome
|
||||
//! when it ends, or is dropped without being called when the backend lost track of it.
|
||||
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// How a drag ended.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Outcome {
|
||||
/// A target accepted the drop.
|
||||
Dropped,
|
||||
/// Released where nothing accepted it, or cancelled with Escape.
|
||||
Cancelled,
|
||||
}
|
||||
|
||||
/// The paths a drag may carry: at least one, each an absolute path to a file or folder
|
||||
/// on this machine. A remote project's paths name files on its server and fail here.
|
||||
/// Windows also refuses paths of `MAX_PATH` or more: Explorer can't copy from them.
|
||||
/// Network shares (`\\server\share\…`) are local paths here and drag like any other.
|
||||
pub fn local_paths<S: Into<PathBuf>>(paths: impl IntoIterator<Item = S>) -> io::Result<Vec<PathBuf>> {
|
||||
let paths: Vec<PathBuf> = paths.into_iter().map(Into::into).collect();
|
||||
if paths.is_empty() {
|
||||
return Err(io::Error::new(io::ErrorKind::InvalidInput, "no files to drag"));
|
||||
}
|
||||
for path in &paths {
|
||||
if !path.is_absolute() || std::fs::symlink_metadata(path).is_err() {
|
||||
return Err(io::Error::new(io::ErrorKind::NotFound, format!("not a local file: {}", path.display())));
|
||||
}
|
||||
if cfg!(windows) && !fits_max_path(path) {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
format!("path too long to drag: {}", path.display()),
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(paths)
|
||||
}
|
||||
|
||||
/// Whether `path` is shorter than Windows' `MAX_PATH` (260 UTF-16 units with the NUL).
|
||||
fn fits_max_path(path: &std::path::Path) -> bool {
|
||||
path.as_os_str().to_string_lossy().encode_utf16().count() < 260
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
pub use gtk_impl::start;
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
mod gtk_impl {
|
||||
use super::Outcome;
|
||||
use gtk::glib::{self, SignalHandlerId};
|
||||
use gtk::prelude::*;
|
||||
use gtk::{TargetList, gdk};
|
||||
use std::cell::{Cell, RefCell};
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
use std::rc::Rc;
|
||||
|
||||
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`; `done` runs on
|
||||
/// the UI thread when the drag ends.
|
||||
pub fn start(
|
||||
window: >k::ApplicationWindow,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
// `file://` URIs with every reserved or non-ASCII byte escaped.
|
||||
let uris = paths
|
||||
.iter()
|
||||
.map(|path| glib::filename_to_uri(path, None).map(|uri| uri.to_string()))
|
||||
.collect::<Result<Vec<_>, _>>()
|
||||
.map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error.to_string()))?;
|
||||
let targets = TargetList::new(&[]);
|
||||
targets.add_uri_targets(0);
|
||||
// The button that started the drag (1), not its mask: GTK ends the drag on that
|
||||
// button's release.
|
||||
let context = window
|
||||
.drag_begin_with_coordinates(&targets, gdk::DragAction::COPY, 1, None, -1, -1)
|
||||
.ok_or_else(|| io::Error::other("the window system refused to start a drag"))?;
|
||||
|
||||
let outcome = Rc::new(Cell::new(Outcome::Cancelled));
|
||||
context.connect_drop_performed({
|
||||
let outcome = outcome.clone();
|
||||
move |_, _| outcome.set(Outcome::Dropped)
|
||||
});
|
||||
let handlers: Rc<RefCell<Vec<SignalHandlerId>>> = Rc::default();
|
||||
let data = window.connect_drag_data_get({
|
||||
let context = context.clone();
|
||||
move |_, ctx, selection, _, _| {
|
||||
if *ctx == context {
|
||||
let uris: Vec<&str> = uris.iter().map(String::as_str).collect();
|
||||
selection.set_uris(&uris);
|
||||
}
|
||||
}
|
||||
});
|
||||
// The target asks for the data after the drop (XDND is asynchronous), so the data
|
||||
// handler stays connected until `drag-end`, which GTK emits last.
|
||||
let done = Cell::new(Some(done));
|
||||
let end = window.connect_drag_end({
|
||||
let handlers = handlers.clone();
|
||||
move |window, ctx| {
|
||||
if *ctx != context {
|
||||
return;
|
||||
}
|
||||
for handler in handlers.borrow_mut().drain(..) {
|
||||
window.disconnect(handler);
|
||||
}
|
||||
if let Some(done) = done.take() {
|
||||
done(outcome.get());
|
||||
}
|
||||
}
|
||||
});
|
||||
handlers.borrow_mut().extend([data, end]);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
mod ole;
|
||||
#[cfg(windows)]
|
||||
pub use ole::start;
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
mod appkit;
|
||||
#[cfg(target_os = "macos")]
|
||||
pub use appkit::start;
|
||||
|
||||
/// The `CF_HDROP` file list: each path in UTF-16 with `/` as `\\`, NUL-terminated, and a
|
||||
/// second NUL after the last.
|
||||
#[cfg(any(windows, test))]
|
||||
fn hdrop_file_list<P: IntoIterator<Item = u16>>(paths: impl IntoIterator<Item = P>) -> Vec<u16> {
|
||||
let mut list = Vec::new();
|
||||
for path in paths {
|
||||
list.extend(path.into_iter().map(|unit| if unit == u16::from(b'/') { u16::from(b'\\') } else { unit }));
|
||||
list.push(0);
|
||||
}
|
||||
list.push(0);
|
||||
list
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn accepts_existing_absolute_files_and_folders() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let file = dir.path().join("a b ü.txt");
|
||||
std::fs::write(&file, "x").unwrap();
|
||||
let paths = local_paths([file.clone(), dir.path().to_path_buf()]).unwrap();
|
||||
assert_eq!(paths, vec![file, dir.path().to_path_buf()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn measures_max_path_in_utf16_units() {
|
||||
let path = |len: usize| PathBuf::from(format!("C:/{}", "中".repeat(len - 3)));
|
||||
assert!(fits_max_path(&path(259)));
|
||||
assert!(!fits_max_path(&path(260)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lists_hdrop_files_double_nul_terminated() {
|
||||
let list = hdrop_file_list(["C:/a b/ü.txt", r"\\nas\share\中"].map(str::encode_utf16));
|
||||
let expected: Vec<u16> = "C:\\a b\\ü.txt\0\\\\nas\\share\\中\0\0".encode_utf16().collect();
|
||||
assert_eq!(list, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_an_empty_drag() {
|
||||
assert_eq!(local_paths(Vec::<PathBuf>::new()).unwrap_err().kind(), io::ErrorKind::InvalidInput);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_relative_and_missing_paths() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let file = dir.path().join("a.txt");
|
||||
std::fs::write(&file, "x").unwrap();
|
||||
// One path that is not local fails the whole drag: none of it is half-copied.
|
||||
for bad in [PathBuf::from("a.txt"), dir.path().join("missing.txt")] {
|
||||
assert_eq!(local_paths([file.clone(), bad]).unwrap_err().kind(), io::ErrorKind::NotFound);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,171 +0,0 @@
|
||||
//! Windows: OLE `DoDragDrop` of a data object that serves the paths as `CF_HDROP`.
|
||||
|
||||
use super::{Outcome, hdrop_file_list};
|
||||
use raw_window_handle::HasWindowHandle;
|
||||
use std::io;
|
||||
use std::os::windows::ffi::OsStrExt;
|
||||
use std::path::PathBuf;
|
||||
use windows::Win32::Foundation::{
|
||||
DRAGDROP_S_CANCEL, DRAGDROP_S_DROP, DRAGDROP_S_USEDEFAULTCURSORS, DV_E_FORMATETC, E_NOTIMPL, GlobalFree, HGLOBAL,
|
||||
OLE_E_ADVISENOTSUPPORTED, S_OK,
|
||||
};
|
||||
use windows::Win32::System::Com::{
|
||||
DATADIR_GET, DVASPECT_CONTENT, FORMATETC, IAdviseSink, IDataObject, IDataObject_Impl, IEnumFORMATETC,
|
||||
IEnumSTATDATA, STGMEDIUM, STGMEDIUM_0, TYMED_HGLOBAL,
|
||||
};
|
||||
use windows::Win32::System::Memory::{GHND, GlobalAlloc, GlobalLock, GlobalUnlock};
|
||||
use windows::Win32::System::Ole::{
|
||||
CF_HDROP, DROPEFFECT, DROPEFFECT_COPY, DROPEFFECT_NONE, DoDragDrop, IDropSource, IDropSource_Impl, OleInitialize,
|
||||
OleUninitialize,
|
||||
};
|
||||
use windows::Win32::System::SystemServices::{MK_LBUTTON, MODIFIERKEYS_FLAGS};
|
||||
use windows::Win32::UI::Shell::{DROPFILES, SHCreateDataObject, SHCreateStdEnumFmtEtc};
|
||||
use windows::core::{BOOL, Error, HRESULT, Ref, Result, implement};
|
||||
|
||||
/// Drags `paths` (see [`super::local_paths`]) until the button is released, then calls
|
||||
/// `done` and returns. `DoDragDrop` runs its own message loop, so the window keeps painting.
|
||||
pub fn start<W: HasWindowHandle>(
|
||||
_window: &W,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
let files = hdrop_file_list(paths.iter().map(|path| path.as_os_str().encode_wide()));
|
||||
// The window's event loop has initialised OLE on this thread already; this takes a
|
||||
// reference that `OleUninitialize` gives back.
|
||||
unsafe { OleInitialize(None) }.map_err(io::Error::other)?;
|
||||
let outcome = drag(files);
|
||||
unsafe { OleUninitialize() };
|
||||
done(outcome.map_err(io::Error::other)?);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn drag(files: Vec<u16>) -> Result<Outcome> {
|
||||
// Formats other than `CF_HDROP` (the drag image, drop descriptions the shell sets on
|
||||
// the source's data object) are kept by a plain shell data object.
|
||||
let inner: IDataObject = unsafe { SHCreateDataObject(None, None, None::<&IDataObject>) }?;
|
||||
let data: IDataObject = DataObject { files, inner }.into();
|
||||
let source: IDropSource = DropSource.into();
|
||||
let mut effect = DROPEFFECT_NONE;
|
||||
match unsafe { DoDragDrop(&data, &source, DROPEFFECT_COPY, &mut effect) } {
|
||||
DRAGDROP_S_DROP if effect != DROPEFFECT_NONE => Ok(Outcome::Dropped),
|
||||
DRAGDROP_S_DROP | DRAGDROP_S_CANCEL => Ok(Outcome::Cancelled),
|
||||
error => Err(Error::from_hresult(error)),
|
||||
}
|
||||
}
|
||||
|
||||
#[implement(IDropSource)]
|
||||
struct DropSource;
|
||||
|
||||
impl IDropSource_Impl for DropSource_Impl {
|
||||
fn QueryContinueDrag(&self, escape_pressed: BOOL, keys: MODIFIERKEYS_FLAGS) -> HRESULT {
|
||||
if escape_pressed.as_bool() {
|
||||
DRAGDROP_S_CANCEL
|
||||
} else if keys & MK_LBUTTON == MODIFIERKEYS_FLAGS(0) {
|
||||
DRAGDROP_S_DROP
|
||||
} else {
|
||||
S_OK
|
||||
}
|
||||
}
|
||||
|
||||
fn GiveFeedback(&self, _effect: DROPEFFECT) -> HRESULT {
|
||||
DRAGDROP_S_USEDEFAULTCURSORS
|
||||
}
|
||||
}
|
||||
|
||||
#[implement(IDataObject)]
|
||||
struct DataObject {
|
||||
/// The `DROPFILES` file list ([`hdrop_file_list`]).
|
||||
files: Vec<u16>,
|
||||
inner: IDataObject,
|
||||
}
|
||||
|
||||
const HDROP: FORMATETC = FORMATETC {
|
||||
cfFormat: CF_HDROP.0,
|
||||
ptd: std::ptr::null_mut(),
|
||||
dwAspect: DVASPECT_CONTENT.0,
|
||||
lindex: -1,
|
||||
tymed: TYMED_HGLOBAL.0 as u32,
|
||||
};
|
||||
|
||||
fn is_hdrop(format: *const FORMATETC) -> bool {
|
||||
unsafe { format.as_ref() }.is_some_and(|format| {
|
||||
format.cfFormat == HDROP.cfFormat && format.dwAspect == HDROP.dwAspect && format.tymed & HDROP.tymed != 0
|
||||
})
|
||||
}
|
||||
|
||||
impl DataObject {
|
||||
/// A new `DROPFILES` block; the receiver frees it.
|
||||
fn hdrop(&self) -> Result<HGLOBAL> {
|
||||
let header = size_of::<DROPFILES>();
|
||||
let size = header + std::mem::size_of_val(self.files.as_slice());
|
||||
unsafe {
|
||||
let handle = GlobalAlloc(GHND, size)?;
|
||||
let block = GlobalLock(handle).cast::<u8>();
|
||||
if block.is_null() {
|
||||
let error = Error::from_thread();
|
||||
let _ = GlobalFree(Some(handle));
|
||||
return Err(error);
|
||||
}
|
||||
block.cast::<DROPFILES>().write_unaligned(DROPFILES {
|
||||
pFiles: header as u32,
|
||||
fWide: true.into(),
|
||||
..Default::default()
|
||||
});
|
||||
std::ptr::copy_nonoverlapping(self.files.as_ptr().cast::<u8>(), block.add(header), size - header);
|
||||
// Fails with no error once the lock count is back to zero, which it is.
|
||||
let _ = GlobalUnlock(handle);
|
||||
Ok(handle)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl IDataObject_Impl for DataObject_Impl {
|
||||
fn GetData(&self, format: *const FORMATETC) -> Result<STGMEDIUM> {
|
||||
if !is_hdrop(format) {
|
||||
return unsafe { self.inner.GetData(format) };
|
||||
}
|
||||
Ok(STGMEDIUM {
|
||||
tymed: TYMED_HGLOBAL.0 as u32,
|
||||
u: STGMEDIUM_0 { hGlobal: self.hdrop()? },
|
||||
pUnkForRelease: std::mem::ManuallyDrop::new(None),
|
||||
})
|
||||
}
|
||||
|
||||
fn GetDataHere(&self, format: *const FORMATETC, medium: *mut STGMEDIUM) -> Result<()> {
|
||||
if is_hdrop(format) {
|
||||
return Err(DV_E_FORMATETC.into());
|
||||
}
|
||||
unsafe { self.inner.GetDataHere(format, medium) }
|
||||
}
|
||||
|
||||
fn QueryGetData(&self, format: *const FORMATETC) -> HRESULT {
|
||||
if is_hdrop(format) { S_OK } else { unsafe { self.inner.QueryGetData(format) } }
|
||||
}
|
||||
|
||||
fn GetCanonicalFormatEtc(&self, format: *const FORMATETC, canonical: *mut FORMATETC) -> HRESULT {
|
||||
unsafe { self.inner.GetCanonicalFormatEtc(format, canonical) }
|
||||
}
|
||||
|
||||
fn SetData(&self, format: *const FORMATETC, medium: *const STGMEDIUM, release: BOOL) -> Result<()> {
|
||||
unsafe { self.inner.SetData(format, medium, release.as_bool()) }
|
||||
}
|
||||
|
||||
fn EnumFormatEtc(&self, direction: u32) -> Result<IEnumFORMATETC> {
|
||||
if direction != DATADIR_GET.0 as u32 {
|
||||
return Err(E_NOTIMPL.into());
|
||||
}
|
||||
unsafe { SHCreateStdEnumFmtEtc(&[HDROP]) }
|
||||
}
|
||||
|
||||
fn DAdvise(&self, _format: *const FORMATETC, _advf: u32, _sink: Ref<IAdviseSink>) -> Result<u32> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
|
||||
fn DUnadvise(&self, _connection: u32) -> Result<()> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
|
||||
fn EnumDAdvise(&self) -> Result<IEnumSTATDATA> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
}
|
||||
@@ -72,7 +72,7 @@ pub struct Host {
|
||||
/// Projects the MCP server serves without a window.
|
||||
pub mcp_background: mcp::BackgroundProjects,
|
||||
pub(crate) agent_catalogs: Arc<ide_agent::AgentCatalogs>,
|
||||
pub trust: std::sync::Arc<trust::TrustStore>,
|
||||
pub trust: trust::TrustStore,
|
||||
pub(crate) mcp_approvals: Arc<trust::McpServerApprovals>,
|
||||
pub config_dir: PathBuf,
|
||||
/// Persistent user state, including credentials and recovery history.
|
||||
@@ -169,7 +169,7 @@ impl Host {
|
||||
mcp_agent_runs: Default::default(),
|
||||
mcp_background: Default::default(),
|
||||
agent_catalogs: Arc::default(),
|
||||
trust: std::sync::Arc::new(trust::TrustStore::load(&config_dir, &data_dir)),
|
||||
trust: trust::TrustStore::load(&config_dir, &data_dir),
|
||||
mcp_approvals: Arc::new(trust::McpServerApprovals::load(&data_dir)),
|
||||
proxy_password: ide_ssh::secrets::SecretFile::new(data_dir.join("proxy-password.json")),
|
||||
proxy_session_password: Mutex::default(),
|
||||
|
||||
@@ -668,8 +668,8 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
|
||||
if hits.len() > limit {
|
||||
break;
|
||||
}
|
||||
// Find in Files reports a very long line in windows cut around its matches: such lines
|
||||
// are matched again in the file's whole text, so a match keeps its real end.
|
||||
// Find in Files keeps a window of very long lines and drops the matches outside it:
|
||||
// such lines are matched again in the file's whole text.
|
||||
let long = |m: &ide_search::LineMatch| m.text_offset > 0 || m.text.encode_utf16().count() + 1 >= LINE_WINDOW;
|
||||
let whole = if file.matches.iter().any(long) {
|
||||
crate::ops::fs::fs_read_text(&host, call.window(), file.path.0.clone())
|
||||
@@ -679,15 +679,11 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
|
||||
} else {
|
||||
None
|
||||
};
|
||||
// One window per far-apart match: a line is expanded once.
|
||||
let mut expanded = std::collections::HashSet::new();
|
||||
for m in &file.matches {
|
||||
if let Some((ranges, text)) = &whole
|
||||
&& long(m)
|
||||
{
|
||||
if expanded.insert(m.line) {
|
||||
hits.extend(line_hits(path, text, ranges, m.line));
|
||||
}
|
||||
hits.extend(line_hits(path, text, ranges, m.line));
|
||||
continue;
|
||||
}
|
||||
let line_end = m.text_offset + m.text.encode_utf16().count() as u32;
|
||||
|
||||
@@ -5,11 +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, AgentSkillMode, AgentSkillPolicy, AgentSkillState, AgentTask,
|
||||
CustomAgentInput, ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer,
|
||||
McpServerInput, McpTransport, NewAgentTask, SkillsPolicy,
|
||||
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, 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;
|
||||
@@ -18,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)]
|
||||
@@ -360,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)]
|
||||
@@ -412,13 +351,6 @@ pub async fn agent_probe(host: &Host, window: &str, provider: String, refresh: b
|
||||
host.project(window)?.agents.probe(&provider, refresh).await
|
||||
}
|
||||
|
||||
/// Reads the running session's context categories without sending a prompt.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_context_usage(host: &Host, window: &str, task: String) -> IdeResult<AgentContextUsage> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.context_usage(&task).await
|
||||
}
|
||||
|
||||
/// Stops the task's current turn, or with `subagent` only that subagent's work.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
|
||||
@@ -1029,148 +961,6 @@ pub fn agent_set_mcp_overrides(
|
||||
host.project(window)?.agents.set_mcp_overrides(&task, overrides)
|
||||
}
|
||||
|
||||
/// Updates per-session skill modes on `task`.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_set_skill_overrides(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
overrides: std::collections::BTreeMap<String, AgentSkillMode>,
|
||||
) -> IdeResult<AgentTask> {
|
||||
host.project(window)?.agents.set_skill_overrides(&task, overrides)
|
||||
}
|
||||
|
||||
/// Every skill discovered in the project and the user's folders, with the mode a session
|
||||
/// of this project runs it with (without any session's own overrides).
|
||||
#[command(trust = always)]
|
||||
pub async fn agent_skills_list(host: &Host, window: &str) -> IdeResult<Vec<AgentSkillState>> {
|
||||
let project = host.project(window)?;
|
||||
let root = project.root.clone();
|
||||
let (policy, home) = (skills_policy(&project), dirs::home_dir());
|
||||
tokio::task::spawn_blocking(move || {
|
||||
Ok(ide_agent::skills::resolve(
|
||||
ide_agent::skills::discover_skills(&root, home.as_deref()),
|
||||
None,
|
||||
&policy.workspace,
|
||||
&policy.user,
|
||||
policy.workspace_trusted,
|
||||
))
|
||||
})
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
}
|
||||
|
||||
/// Sets how `name` may run in `scope`, in the settings file of that scope, and returns the
|
||||
/// updated list. `SKILL.md` files are never touched; the default `auto` removes the entry.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_skills_set_mode(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
name: String,
|
||||
scope: McpScope,
|
||||
mode: AgentSkillMode,
|
||||
) -> IdeResult<Vec<AgentSkillState>> {
|
||||
let name = name.trim().to_owned();
|
||||
if name.is_empty() {
|
||||
return Err(IdeError::invalid("a skill needs a name"));
|
||||
}
|
||||
let project = host.project(window).ok().filter(|p| !p.light);
|
||||
let (mut user, mut workspace) = skills_maps(host, project.as_ref());
|
||||
match scope {
|
||||
McpScope::User => {
|
||||
let changed = if mode == AgentSkillMode::Auto {
|
||||
user.remove(&name).is_some()
|
||||
} else {
|
||||
user.insert(name, AgentSkillPolicy { mode }).map(|p| p.mode) != Some(mode)
|
||||
};
|
||||
if changed {
|
||||
persist_skills_map(host, None, scope, &user)?;
|
||||
}
|
||||
}
|
||||
McpScope::Workspace => {
|
||||
let map =
|
||||
workspace.as_mut().ok_or_else(|| IdeError::invalid("Open a project to configure workspace skills"))?;
|
||||
let changed = if mode == AgentSkillMode::Auto {
|
||||
map.remove(&name).is_some()
|
||||
} else {
|
||||
map.insert(name, AgentSkillPolicy { mode }).map(|p| p.mode) != Some(mode)
|
||||
};
|
||||
if changed {
|
||||
let map = map.clone();
|
||||
persist_skills_map(host, project.as_ref(), scope, &map)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
match project {
|
||||
Some(project) => {
|
||||
let root = project.root.clone();
|
||||
let policy = skills_policy(&project);
|
||||
let home = dirs::home_dir();
|
||||
Ok(ide_agent::skills::resolve(
|
||||
ide_agent::skills::discover_skills(&root, home.as_deref()),
|
||||
None,
|
||||
&policy.workspace,
|
||||
&policy.user,
|
||||
policy.workspace_trusted,
|
||||
))
|
||||
}
|
||||
None => Ok(Vec::new()),
|
||||
}
|
||||
}
|
||||
|
||||
/// The user's and the workspace's skill policies (`[agents.skills.<name>]`).
|
||||
fn skills_maps(
|
||||
host: &Host,
|
||||
project: Option<&std::sync::Arc<crate::Project>>,
|
||||
) -> (std::collections::BTreeMap<String, AgentSkillPolicy>, Option<std::collections::BTreeMap<String, AgentSkillPolicy>>)
|
||||
{
|
||||
let user = host.global_settings.effective().agents.skills.clone();
|
||||
let workspace =
|
||||
project.map(|p| p.settings.layer(ide_workspace::settings::SettingsScope::Project).agents.skills.clone());
|
||||
(user, workspace)
|
||||
}
|
||||
|
||||
/// Saves `map` into its scope's settings and tells the windows.
|
||||
fn persist_skills_map(
|
||||
host: &Host,
|
||||
project: Option<&std::sync::Arc<crate::Project>>,
|
||||
scope: McpScope,
|
||||
map: &std::collections::BTreeMap<String, AgentSkillPolicy>,
|
||||
) -> IdeResult<()> {
|
||||
let value = if map.is_empty() {
|
||||
serde_json::Value::Null
|
||||
} else {
|
||||
serde_json::to_value(map).map_err(|e| IdeError::invalid(e.to_string()))?
|
||||
};
|
||||
let event = IdeEvent::SettingsChanged { key: "agents.skills".into() };
|
||||
match scope {
|
||||
McpScope::User => {
|
||||
host.global_settings.set(ide_workspace::settings::SettingsScope::Global, "agents.skills", value)?;
|
||||
for p in host.projects() {
|
||||
p.settings.reload();
|
||||
p.agents.notify_mcp_servers_changed();
|
||||
p.sink.emit(event.clone());
|
||||
}
|
||||
}
|
||||
McpScope::Workspace => {
|
||||
let p = project.ok_or_else(|| IdeError::invalid("Open a project to configure workspace skills"))?;
|
||||
p.settings.set(ide_workspace::settings::SettingsScope::Project, "agents.skills", value)?;
|
||||
p.agents.notify_mcp_servers_changed();
|
||||
p.sink.emit(event);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The skill policies a session of `project` resolves against.
|
||||
fn skills_policy(project: &crate::Project) -> SkillsPolicy {
|
||||
SkillsPolicy {
|
||||
user: project.settings.layer(ide_workspace::settings::SettingsScope::Global).agents.skills.clone(),
|
||||
workspace: project.settings.layer(ide_workspace::settings::SettingsScope::Project).agents.skills.clone(),
|
||||
workspace_trusted: project.trusted.load(std::sync::atomic::Ordering::Acquire),
|
||||
}
|
||||
}
|
||||
|
||||
fn validate_project_root(root: &std::path::Path, requested: Option<&std::path::Path>) -> IdeResult<std::path::PathBuf> {
|
||||
let Some(requested) = requested else {
|
||||
return Ok(root.to_path_buf());
|
||||
@@ -1287,10 +1077,7 @@ ide_command::domain!(
|
||||
agent_archive,
|
||||
agent_base_text,
|
||||
agent_cancel,
|
||||
agent_context_usage,
|
||||
agent_changes,
|
||||
agent_cli_update,
|
||||
agent_cli_update_check,
|
||||
agent_commands,
|
||||
agent_create,
|
||||
agent_delete,
|
||||
@@ -1326,12 +1113,8 @@ ide_command::domain!(
|
||||
agent_set_config,
|
||||
agent_set_env,
|
||||
agent_set_mcp_overrides,
|
||||
agent_set_skill_overrides,
|
||||
agent_skills_list,
|
||||
agent_skills_set_mode,
|
||||
agent_stop_background,
|
||||
agent_subscribe,
|
||||
agent_unarchive,
|
||||
agent_unqueue,
|
||||
agent_unsubscribe,
|
||||
);
|
||||
@@ -1,7 +1,6 @@
|
||||
//! Cucumber sources: the project's `.feature` files and the JavaScript / TypeScript files
|
||||
//! (`@cucumber/cucumber`, `playwright-bdd`) and Java / Kotlin files (cucumber-jvm's
|
||||
//! `@Given("…")` annotations and Java 8 lambdas) and Python files (behave and pytest-bdd's
|
||||
//! `@given('…')` decorators) that could define steps, with their text. The UI
|
||||
//! `@Given("…")` annotations and Java 8 lambdas) that could define steps, with their text. The UI
|
||||
//! owns the Gherkin and step-expression parsing and the index it feeds (as for `routes`),
|
||||
//! so this side stays a cheap scan.
|
||||
|
||||
@@ -22,8 +21,6 @@ const MAX_FILE_BYTES: u64 = 2 << 20;
|
||||
|
||||
/// What a step definition call starts with (`Given('…'`, `defineStep(/…/`).
|
||||
const STEP_CALLS: [&str; 5] = ["Given(", "When(", "Then(", "Step(", "defineStep("];
|
||||
/** What a Python step decorator starts with (behave also takes the capitalized names). */
|
||||
const PYTHON_STEP_CALLS: [&str; 8] = ["@given(", "@when(", "@then(", "@step(", "@Given(", "@When(", "@Then(", "@Step("];
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -41,14 +38,10 @@ fn is_feature(path: &Path) -> bool {
|
||||
fn is_script(path: &Path) -> bool {
|
||||
matches!(
|
||||
path.extension().and_then(|e| e.to_str()),
|
||||
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt" | "py")
|
||||
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt")
|
||||
)
|
||||
}
|
||||
|
||||
fn is_python(path: &Path) -> bool {
|
||||
path.extension().and_then(|e| e.to_str()) == Some("py")
|
||||
}
|
||||
|
||||
/// The feature files and step definition files under `root`.
|
||||
pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
|
||||
let found: Mutex<Vec<StepSource>> = Mutex::new(Vec::new());
|
||||
@@ -62,8 +55,7 @@ pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
|
||||
return;
|
||||
}
|
||||
let Ok(text) = std::fs::read_to_string(path) else { return };
|
||||
let calls: &[&str] = if is_python(path) { &PYTHON_STEP_CALLS } else { &STEP_CALLS };
|
||||
if !feature && !calls.iter().any(|call| text.contains(call)) {
|
||||
if !feature && !STEP_CALLS.iter().any(|call| text.contains(call)) {
|
||||
return;
|
||||
}
|
||||
let Ok(mut found) = found.lock() else { return };
|
||||
@@ -84,7 +76,6 @@ pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult<Vec<StepSource>>
|
||||
let mut excludes = project.search_excludes();
|
||||
// Cucumber's own sources (and every other package's) are not the project's steps.
|
||||
excludes.push("node_modules".to_owned());
|
||||
excludes.push("site-packages".to_owned());
|
||||
let mut out = Vec::new();
|
||||
for root in std::iter::once(project.root.clone()).chain(project.content_roots()) {
|
||||
out.extend(sources_in(&root, &excludes));
|
||||
@@ -113,23 +104,11 @@ mod tests {
|
||||
std::fs::write(root.join("src/CartSteps.java"), "@Given(\"an empty cart\")\npublic void empty() {}").unwrap();
|
||||
std::fs::write(root.join("src/App.java"), "class App {}").unwrap();
|
||||
std::fs::write(root.join("src/notes.md"), "Given('x')").unwrap();
|
||||
std::fs::write(root.join("steps/cart_steps.py"), "@given('an empty cart')\ndef step_impl(context): pass")
|
||||
.unwrap();
|
||||
std::fs::write(root.join("src/util.py"), "def given(x): return x\nWhen = given('x')").unwrap();
|
||||
std::fs::write(root.join("node_modules/@cucumber/cucumber/lib/index.js"), "Given('x')").unwrap();
|
||||
let files = sources_in(root, &["node_modules".to_owned()]);
|
||||
let names: Vec<String> =
|
||||
files.iter().map(|f| f.path.0.strip_prefix(root).unwrap().to_string_lossy().replace('\\', "/")).collect();
|
||||
assert_eq!(
|
||||
names,
|
||||
[
|
||||
"features/cart.feature",
|
||||
"src/CartSteps.java",
|
||||
"steps/bdd.mjs",
|
||||
"steps/cart.steps.ts",
|
||||
"steps/cart_steps.py"
|
||||
]
|
||||
);
|
||||
assert_eq!(names, ["features/cart.feature", "src/CartSteps.java", "steps/bdd.mjs", "steps/cart.steps.ts"]);
|
||||
assert!(files[0].feature && !files[1].feature);
|
||||
assert!(files[3].text.contains("an empty cart"));
|
||||
}
|
||||
|
||||
@@ -8,79 +8,30 @@ use crate::{Host, Project};
|
||||
use ide_command::command;
|
||||
|
||||
use ide_build::compile::{self, BuildEvent, BuildKind, BuildResult};
|
||||
use ide_build::maven::PomGoto;
|
||||
use ide_build::maven::completion::{PomCompletion, PomCompletionOption};
|
||||
use ide_build::maven::{PomGoto, PomManagedDeclaration, PomNavigationOptions};
|
||||
use ide_build::pom_edit::{ArtifactKey, Exclusion};
|
||||
use ide_build::{BuildModel, BuildTool, SyncOptions, SyncProgress};
|
||||
use ide_core::settings::Settings;
|
||||
use ide_core::{DocId, FileEdit, IdeError, IdeEvent, IdeResult, Location, Pos, Range, RequestId, WorkspaceEdit};
|
||||
use std::collections::HashMap;
|
||||
use std::path::Path;
|
||||
use std::sync::{Arc, Mutex, OnceLock};
|
||||
use std::time::{Duration, Instant};
|
||||
use std::sync::Arc;
|
||||
|
||||
fn join_err(e: tokio::task::JoinError) -> IdeError {
|
||||
IdeError::internal(e.to_string())
|
||||
}
|
||||
|
||||
/// POM gutters in several editors refresh together. A very short cache lets those
|
||||
/// requests share one reactor scan without serving a stale module list after edits settle.
|
||||
const MAVEN_MODULE_CACHE_TTL: Duration = Duration::from_millis(250);
|
||||
type MavenModuleCache = HashMap<String, (Instant, Vec<ide_build::maven::ModulePom>)>;
|
||||
static MAVEN_MODULES: OnceLock<Mutex<MavenModuleCache>> = OnceLock::new();
|
||||
|
||||
fn maven_modules(
|
||||
project: &Project,
|
||||
settings: &Settings,
|
||||
options: &PomNavigationOptions,
|
||||
) -> Vec<ide_build::maven::ModulePom> {
|
||||
let key = format!(
|
||||
"{}\0{:?}\0{:?}\0{:?}\0{:?}",
|
||||
project.root.display(),
|
||||
project.build_cache_dir(),
|
||||
settings.languages.java.maven.linked_projects,
|
||||
options.profiles,
|
||||
options.jdk_version
|
||||
);
|
||||
let cache = MAVEN_MODULES.get_or_init(|| Mutex::new(HashMap::new()));
|
||||
if let Some((_at, modules)) = cache.lock().ok().and_then(|mut cache| {
|
||||
let fresh = cache.get(&key).filter(|(at, _)| at.elapsed() < MAVEN_MODULE_CACHE_TTL).cloned();
|
||||
if fresh.is_none() {
|
||||
cache.remove(&key);
|
||||
}
|
||||
fresh
|
||||
}) {
|
||||
return modules;
|
||||
}
|
||||
let model = load(&project.root, &project.build_cache_dir(), settings).maven.unwrap_or_default();
|
||||
let modules = model
|
||||
.projects
|
||||
.into_iter()
|
||||
.map(|p| ide_build::maven::ModulePom {
|
||||
group_id: p.group_id,
|
||||
artifact_id: p.artifact_id,
|
||||
version: p.version,
|
||||
pom: project.root.join(&p.pom),
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
if let Ok(mut cache) = cache.lock() {
|
||||
cache.insert(key, (Instant::now(), modules.clone()));
|
||||
}
|
||||
modules
|
||||
}
|
||||
|
||||
/// The build model with the launch settings applied: the JDK (`JAVA_HOME`), and
|
||||
/// the Maven home and options from Settings › Maven.
|
||||
pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
|
||||
let jdk = ide_sdk::apply::project_jdk(root, settings);
|
||||
let mut model = ide_build::load_linked_with_jdk(
|
||||
let mut model = ide_build::load_linked(
|
||||
root,
|
||||
cache,
|
||||
ide_sdk::apply::maven_local_repository(root, settings),
|
||||
&settings.languages.java.maven,
|
||||
&settings.languages.java.gradle,
|
||||
ide_sdk::apply::maven_jdk(root, settings, None).map(|jdk| jdk.major),
|
||||
);
|
||||
let jdk = ide_sdk::apply::project_jdk(root, settings);
|
||||
if let Some(m) = &mut model.maven {
|
||||
let mvn = ide_sdk::apply::maven_command(root, settings);
|
||||
let options = ide_sdk::apply::maven_options(root, settings);
|
||||
@@ -126,23 +77,6 @@ pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
|
||||
model
|
||||
}
|
||||
|
||||
/// POM navigation follows the same profile choices as the last Maven sync and
|
||||
/// resolves JDK-activated profiles with the project's selected Maven runtime.
|
||||
fn pom_navigation_options(project: &Project, settings: &Settings) -> PomNavigationOptions {
|
||||
let mut profiles = settings.languages.java.maven.profiles(&[]);
|
||||
for profile in ide_build::maven_profiles(&project.build_cache_dir()) {
|
||||
if !profiles.contains(&profile) {
|
||||
profiles.push(profile);
|
||||
}
|
||||
}
|
||||
PomNavigationOptions {
|
||||
local_repo: ide_sdk::apply::maven_local_repository(&project.root, settings)
|
||||
.or_else(ide_build::maven::default_local_repo),
|
||||
profiles,
|
||||
jdk_version: ide_sdk::apply::maven_jdk(&project.root, settings, None).map(|jdk| jdk.major),
|
||||
}
|
||||
}
|
||||
|
||||
/// Build and Run use the same selected toolchain and module-local runtime discovery.
|
||||
fn prepare_plan(mut plan: compile::BuildPlan, root: &Path, settings: &Settings) -> compile::BuildPlan {
|
||||
let kind = match plan.system {
|
||||
@@ -613,9 +547,8 @@ pub async fn maven_dependency_declaration(
|
||||
}
|
||||
|
||||
/// The go-to-declaration target at `pos` of a Maven POM: the definition of the
|
||||
/// `${property}` at the caret, the parent POM, or the dependency / plugin's own POM
|
||||
/// (a project module first, then the local repository). A dependency without a
|
||||
/// resolvable artifact POM falls back to its management entry.
|
||||
/// `${property}` at the caret, or the `<dependencyManagement>` / `<pluginManagement>`
|
||||
/// entry providing the dependency's / plugin's version, along the parent chain.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos: Pos) -> IdeResult<Option<PomGoto>> {
|
||||
// `pom` is project-relative, or absolute for a parent POM opened from the local repository.
|
||||
@@ -628,55 +561,26 @@ pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos:
|
||||
let path = if given.is_absolute() { given.to_path_buf() } else { project.root.join(given) };
|
||||
let text = project.text_of(&path)?;
|
||||
let settings = project.settings.effective();
|
||||
let options = pom_navigation_options(&project, &settings);
|
||||
let module_options = options.clone();
|
||||
let modules = || maven_modules(&project, &settings, &module_options);
|
||||
Ok(ide_build::maven::goto_declaration_with(&text, &path, pos, options, modules))
|
||||
let repo = ide_sdk::apply::maven_local_repository(&project.root, &settings)
|
||||
.or_else(ide_build::maven::default_local_repo);
|
||||
let modules = || {
|
||||
let model = load(&project.root, &project.build_cache_dir(), &settings).maven.unwrap_or_default();
|
||||
model
|
||||
.projects
|
||||
.into_iter()
|
||||
.map(|p| ide_build::maven::ModulePom {
|
||||
group_id: p.group_id,
|
||||
artifact_id: p.artifact_id,
|
||||
pom: project.root.join(&p.pom),
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
Ok(ide_build::maven::goto_declaration_in(&text, &path, pos, repo, modules))
|
||||
})
|
||||
.await
|
||||
.map_err(join_err)?
|
||||
}
|
||||
|
||||
/// Gutter targets of the unversioned dependencies and plugins in a Maven POM:
|
||||
/// the management declarations that actually supply their versions, including
|
||||
/// parent POMs and imported BOMs. Cancel with `cancel_request(request)`.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn maven_managed_declarations(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
pom: String,
|
||||
request: RequestId,
|
||||
) -> IdeResult<Vec<PomManagedDeclaration>> {
|
||||
let project = host.project(window)?;
|
||||
let cancel = host.begin_project_read_request(window, request);
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let given = Path::new(&pom);
|
||||
let path = if given.is_absolute() { given.to_path_buf() } else { project.root.join(given) };
|
||||
let text = project.text_of(&path)?;
|
||||
let settings = project.settings.effective();
|
||||
let options = pom_navigation_options(&project, &settings);
|
||||
let cancelled = cancel.clone();
|
||||
let module_options = options.clone();
|
||||
let modules = || {
|
||||
if cancelled.is_cancelled() {
|
||||
return Vec::new();
|
||||
}
|
||||
maven_modules(&project, &settings, &module_options)
|
||||
};
|
||||
let declarations = ide_build::maven::managed_declarations_with(&text, &path, options, modules);
|
||||
if cancel.is_cancelled() { Err(IdeError::cancelled()) } else { Ok(declarations) }
|
||||
})
|
||||
.await;
|
||||
host.end_request(request);
|
||||
match result {
|
||||
Ok(result) => result,
|
||||
Err(error) => Err(join_err(error)),
|
||||
}
|
||||
}
|
||||
|
||||
/// How long completion waits for Maven Central before answering from the local repository.
|
||||
const CENTRAL_WAIT: std::time::Duration = std::time::Duration::from_secs(1);
|
||||
|
||||
@@ -1429,5 +1333,4 @@ ide_command::domain!(
|
||||
maven_dependency_declaration,
|
||||
maven_exclude_dependency,
|
||||
maven_goto_declaration,
|
||||
maven_managed_declarations,
|
||||
);
|
||||
@@ -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,
|
||||
|
||||
@@ -70,13 +70,6 @@ pub async fn doc_save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
|
||||
}
|
||||
|
||||
/// Load Changes from Disk: discards the buffer's unsaved changes and reads its file again.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_reload_from_disk(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || project.documents.discard_and_reload(doc)).await
|
||||
}
|
||||
|
||||
/// An automatic save: `false` (nothing written) when the file changed on disk after the
|
||||
/// buffer was edited, which only an explicit save overwrites.
|
||||
#[command(trust = always)]
|
||||
@@ -127,7 +120,6 @@ ide_command::domain!(
|
||||
doc_edit,
|
||||
doc_open,
|
||||
doc_open_untitled,
|
||||
doc_reload_from_disk,
|
||||
doc_save,
|
||||
doc_autosave,
|
||||
doc_save_all,
|
||||
|
||||
@@ -85,7 +85,7 @@ pub async fn doc_set_line_ending(host: &Host, window: &str, doc: DocId, line_end
|
||||
}
|
||||
|
||||
/// Structure view: LSP document symbols when available (with tree-sitter
|
||||
/// visibility and type-alias kinds), tree-sitter otherwise.
|
||||
/// visibility), tree-sitter otherwise.
|
||||
/// Tree-sitter answers come from the per-document tree cache (incremental
|
||||
/// re-parse); large documents get no syntax structure.
|
||||
#[command(trust = always)]
|
||||
@@ -113,13 +113,10 @@ pub async fn doc_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec
|
||||
};
|
||||
let syntax = || project.syntax.outline(doc, &snap.language, snap.version, &snap.text);
|
||||
Ok(match lsp {
|
||||
// Server symbols carry no visibility, nor a kind for type aliases; borrow them from
|
||||
// the syntax tree.
|
||||
// Server symbols carry no visibility; borrow it from the syntax tree.
|
||||
Some(mut items) => {
|
||||
if !snap.large {
|
||||
let syntax = syntax();
|
||||
ide_language::merge_visibility(&mut items, &syntax);
|
||||
ide_language::merge_kinds(&mut items, &syntax);
|
||||
ide_language::merge_visibility(&mut items, &syntax());
|
||||
}
|
||||
items
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use super::*;
|
||||
use crate::{HostConfig, Project};
|
||||
use ide_core::{IdeEvent, TextChange};
|
||||
use ide_core::{IdeEvent, TextChange, event::NotifyLevel};
|
||||
use parking_lot::Mutex;
|
||||
use std::{path::Path, sync::Arc};
|
||||
|
||||
@@ -57,9 +57,7 @@ impl Fixture {
|
||||
self.events
|
||||
.lock()
|
||||
.iter()
|
||||
.filter(|e| {
|
||||
matches!(e, IdeEvent::DocPatched { .. } | IdeEvent::DocDirty { .. } | IdeEvent::DocDiskConflict { .. })
|
||||
})
|
||||
.filter(|e| matches!(e, IdeEvent::DocPatched { .. } | IdeEvent::DocDirty { .. } | IdeEvent::Notify { .. }))
|
||||
.cloned()
|
||||
.collect()
|
||||
}
|
||||
@@ -112,7 +110,7 @@ async fn dirty_document_keeps_edits_and_warns_once() {
|
||||
let loaded = f.project.documents.snapshot(original.id).unwrap();
|
||||
assert_eq!(loaded.text, "local original\n");
|
||||
assert!(loaded.dirty);
|
||||
assert!(matches!(f.document_events().as_slice(), [IdeEvent::DocDiskConflict { .. }]));
|
||||
assert!(matches!(f.document_events().as_slice(), [IdeEvent::Notify { level: NotifyLevel::Warning, .. }]));
|
||||
f.events.lock().clear();
|
||||
f.sync().await;
|
||||
assert!(f.document_events().is_empty());
|
||||
|
||||
@@ -335,12 +335,6 @@ pub fn set_settings(
|
||||
project.agents.notify_mcp_servers_changed();
|
||||
}
|
||||
}
|
||||
// A skill policy change re-resolves the modes; an idle session restarts to pick them up.
|
||||
if key == "agents" || key == "agents.skills" || key.starts_with("agents.skills.") {
|
||||
for project in affected() {
|
||||
project.agents.notify_mcp_servers_changed();
|
||||
}
|
||||
}
|
||||
// A new interpreter / toolchain / server executable restarts the language servers it affects.
|
||||
// So do inspections that are compiler options (`ide-sdk` `configure_java_compiler`).
|
||||
let code_style = key == "editor"
|
||||
|
||||
@@ -122,38 +122,28 @@ pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) ->
|
||||
|
||||
/// The interpreter the project uses: the configured one, else its virtualenv.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn sdk_python_effective(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
near: Option<PathBuf>,
|
||||
) -> IdeResult<Option<ide_core::IpcPath>> {
|
||||
pub fn sdk_python_effective(host: &Host, window: &str, near: Option<PathBuf>) -> IdeResult<Option<ide_core::IpcPath>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
let (config_dir, project_root) = (host.config_dir.clone(), project.root.clone());
|
||||
// Loading a member's settings needs more stack than a sync command's main thread has left.
|
||||
tokio::task::spawn_blocking(move || {
|
||||
let member = ide_workspace::workspace::Workspace::load(&project_root).ok().flatten().and_then(|w| {
|
||||
let near = near.as_deref()?;
|
||||
w.projects.into_iter().filter(|root| near.starts_with(root)).max_by_key(|root| root.components().count())
|
||||
});
|
||||
let (root, settings) = match member {
|
||||
Some(root) => {
|
||||
let settings = ide_workspace::SettingsStore::load(&config_dir, Some(&root)).effective();
|
||||
(root, settings)
|
||||
}
|
||||
None => (project_root.clone(), project.settings.effective()),
|
||||
};
|
||||
// A member with no Python of its own falls back to the primary project's
|
||||
// (the same chain run configurations use), so every answer names one interpreter.
|
||||
let interpreter = ide_sdk::apply::python_interpreter_near(&root, near.as_deref(), &settings).or_else(|| {
|
||||
(root != project_root)
|
||||
.then(|| ide_sdk::apply::python_interpreter(&project_root, &project.settings.effective()))
|
||||
.flatten()
|
||||
});
|
||||
Ok(interpreter.map(Into::into))
|
||||
})
|
||||
.await
|
||||
.map_err(join_err)?
|
||||
let member = ide_workspace::workspace::Workspace::load(&project.root)?.and_then(|w| {
|
||||
let near = near.as_deref()?;
|
||||
w.projects.into_iter().filter(|root| near.starts_with(root)).max_by_key(|root| root.components().count())
|
||||
});
|
||||
let (root, settings) = match member {
|
||||
Some(root) => {
|
||||
let settings = ide_workspace::SettingsStore::load(&host.config_dir, Some(&root)).effective();
|
||||
(root, settings)
|
||||
}
|
||||
None => (project.root.clone(), project.settings.effective()),
|
||||
};
|
||||
// A member with no Python of its own falls back to the primary project's
|
||||
// (the same chain run configurations use), so every answer names one interpreter.
|
||||
let interpreter = ide_sdk::apply::python_interpreter_near(&root, near.as_deref(), &settings).or_else(|| {
|
||||
(root != project.root)
|
||||
.then(|| ide_sdk::apply::python_interpreter(&project.root, &project.settings.effective()))
|
||||
.flatten()
|
||||
});
|
||||
Ok(interpreter.map(Into::into))
|
||||
}
|
||||
|
||||
/// The PHP interpreter chosen in Settings › Languages & Frameworks › PHP; `None`: the `php` on `PATH`.
|
||||
@@ -471,7 +461,7 @@ mod tests {
|
||||
host.open_project("main", &root).unwrap();
|
||||
let detected = sdk_detect(&host, "main", SdkKind::Python).await.unwrap();
|
||||
assert!(detected.iter().any(|s| s.path == sdk.path && s.name == sdk.name));
|
||||
assert_eq!(sdk_python_effective(&host, "main", None).await.unwrap(), Some(sdk.path));
|
||||
assert_eq!(sdk_python_effective(&host, "main", None).unwrap(), Some(sdk.path));
|
||||
assert!(sdk_python_interpreter(&host, "main", root.join("README.md")).await.unwrap().is_none());
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
@@ -22,17 +22,6 @@ pub fn literal_range(l: ide_language::Literal) -> ide_search::LiteralRange {
|
||||
ide_search::LiteralRange { start: l.start, end: l.end, kind }
|
||||
}
|
||||
|
||||
/// Comments and string literals of `text`, for the search context of Find and Replace in Files.
|
||||
pub(crate) fn literals_of(
|
||||
project: &crate::project::Project,
|
||||
syntax: &ide_language::Syntax,
|
||||
path: &Path,
|
||||
text: &str,
|
||||
) -> Option<Vec<ide_search::LiteralRange>> {
|
||||
let language = project.languages.detect(path, text.lines().next());
|
||||
Some(syntax.literals(&language, text)?.into_iter().map(literal_range).collect())
|
||||
}
|
||||
|
||||
/// Find in Files. Results stream through `on_event`; ends with `Done`.
|
||||
/// Cancel with `cancel_request(request)`.
|
||||
#[command(trust = always)]
|
||||
@@ -109,7 +98,10 @@ pub(crate) fn search_project(
|
||||
Some(ProjectFileSet::Test) => roots.is_test(rel),
|
||||
_ => true,
|
||||
};
|
||||
let literals = |path: &Path, text: &str| literals_of(project, syntax, path, text);
|
||||
let literals = |path: &Path, text: &str| {
|
||||
let language = project.languages.detect(path, text.lines().next());
|
||||
Some(syntax.literals(&language, text)?.into_iter().map(literal_range).collect())
|
||||
};
|
||||
let defaults = project.documents.file_defaults();
|
||||
let decode = |path: &Path, bytes: &[u8]| ide_vfs::decode_text(bytes, defaults.fallback_for(path));
|
||||
let mut total = SearchSummary::default();
|
||||
|
||||
@@ -75,19 +75,9 @@ pub async fn replace_in_files(
|
||||
let summary = tokio::task::spawn_blocking(move || {
|
||||
let targets = if all_in_scope { scope_targets(&project, &syntax, &query, targets, &cancel)? } else { targets };
|
||||
let host = DocumentsHost(&project.documents);
|
||||
let literals = |path: &Path, text: &str| super::literals_of(&project, &syntax, path, text);
|
||||
ide_search::replace_files_in_context(
|
||||
&host,
|
||||
&query,
|
||||
&replacement,
|
||||
preserve_case,
|
||||
&targets,
|
||||
Some(&literals),
|
||||
&cancel,
|
||||
&|e| {
|
||||
let _ = events.send(e);
|
||||
},
|
||||
)
|
||||
ide_search::replace_files(&host, &query, &replacement, preserve_case, &targets, &cancel, &|e| {
|
||||
let _ = events.send(e);
|
||||
})
|
||||
})
|
||||
.await
|
||||
.map_err(|e| ide_core::IdeError::internal(e.to_string()));
|
||||
|
||||
@@ -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"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -738,19 +738,6 @@ impl Host {
|
||||
let approvals = self.mcp_approvals.clone();
|
||||
let secrets = self.agent_secrets.clone();
|
||||
let root = root.to_path_buf();
|
||||
// The skill policies sessions resolve against: both settings layers and the
|
||||
// workspace's trust as it stands when a session starts.
|
||||
let skill_settings = settings.clone();
|
||||
let skill_root = root.clone();
|
||||
let trust = self.trust.clone();
|
||||
agents.set_skills_policy_hook(Box::new(move || {
|
||||
let layer = |scope| skill_settings.layer(scope).agents.skills.clone();
|
||||
ide_agent::SkillsPolicy {
|
||||
user: layer(ide_workspace::settings::SettingsScope::Global),
|
||||
workspace: layer(ide_workspace::settings::SettingsScope::Project),
|
||||
workspace_trusted: trust.trusted(&skill_root).unwrap_or(false),
|
||||
}
|
||||
}));
|
||||
agents.set_mcp_servers_hook(Box::new(move || {
|
||||
crate::ops::agent::session_mcp_servers(&settings, &approvals, &secrets, &root)
|
||||
}));
|
||||
|
||||
@@ -191,7 +191,6 @@ pub fn client_accepts(event: &IdeEvent, trusted: bool) -> bool {
|
||||
| IdeEvent::ExcludedDirsChanged { .. }
|
||||
| IdeEvent::DocPatched { .. }
|
||||
| IdeEvent::DocDirty { .. }
|
||||
| IdeEvent::DocDiskConflict { .. }
|
||||
| IdeEvent::WorkspaceEditApplied { .. }
|
||||
| IdeEvent::DocLanguage { .. }
|
||||
| IdeEvent::Diagnostics { .. }
|
||||
|
||||
@@ -161,7 +161,7 @@ async fn light_notebooks_open_without_interpreter_detection_or_execution() {
|
||||
assert!(ops::notebook::notebook_save(&host, "main", notebook.id.clone()).await.is_ok());
|
||||
let error = ops::sdk::sdk_detect(&host, "main", ide_sdk::SdkKind::Python).await.unwrap_err();
|
||||
assert!(error.message.contains("Restricted Mode"));
|
||||
assert!(ops::sdk::sdk_python_effective(&host, "main", None).await.is_err());
|
||||
assert!(ops::sdk::sdk_python_effective(&host, "main", None).is_err());
|
||||
assert!(ops::sdk::sdk_locate_tools(&host, "main", vec!["prettier".into()], Some(root)).await.is_err());
|
||||
let error = ops::notebook::notebook_restart(&host, "main", notebook.id.clone()).await.unwrap_err();
|
||||
assert!(error.message.contains("Restricted Mode"));
|
||||
|
||||
@@ -187,19 +187,6 @@ async fn reads_unsaved_text_and_searches_the_overlay_with_a_limit() {
|
||||
assert_eq!(std::fs::read_to_string(h.root.join("src/a.txt")).unwrap(), "old text\nneedle needle\n");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn every_match_of_a_long_line_is_found_once() {
|
||||
let h = Harness::new();
|
||||
std::fs::write(
|
||||
h.root.join("src/min.js"),
|
||||
format!("a=1;{}b='longneedle';{}longneedle\n", "x".repeat(2000), "y".repeat(2000)),
|
||||
)
|
||||
.unwrap();
|
||||
let found = h.json("search_text", json!({"q":"longneedle","limit":20})).await;
|
||||
let columns: Vec<_> = found["items"].as_array().unwrap().iter().map(|i| i["startColumn"].clone()).collect();
|
||||
assert_eq!(columns, [json!(2008), json!(4020)], "{found}");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn window_reports_supply_editor_selection_and_problems_then_disappear_on_close() {
|
||||
let h = Harness::new();
|
||||
|
||||
@@ -351,7 +351,7 @@ async fn python_venv() {
|
||||
// The project's virtualenv: listed first, and the interpreter the project uses.
|
||||
let found = ops::sdk::sdk_detect(&p.host, WINDOW, ide_sdk::SdkKind::Python).await.unwrap();
|
||||
assert_eq!(found.first().map(|s| s.source.as_str()), Some("venv"), "{found:?}");
|
||||
let effective = ops::sdk::sdk_python_effective(&p.host, WINDOW, None).await.unwrap().expect("an interpreter");
|
||||
let effective = ops::sdk::sdk_python_effective(&p.host, WINDOW, None).unwrap().expect("an interpreter");
|
||||
assert!(effective.starts_with(p.root.join(".venv")), "{effective:?}");
|
||||
}
|
||||
|
||||
|
||||
@@ -195,56 +195,3 @@ async fn replace_all_saves_open_buffers_without_unsaved_changes() {
|
||||
assert_eq!(project.documents.text_snapshot(edited).unwrap().text, "DONE\nmore\n");
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
/// Replace All past the limit replaces what the search lists: only the matches its Search
|
||||
/// Context keeps (comments, string literals or code), as below the limit.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn replace_all_past_the_limit_keeps_to_the_search_context() {
|
||||
use ide_search::SearchContext as C;
|
||||
let comments = |word: &str| lines(2001, &format!("// {word}"));
|
||||
let code = |name: &str, string: &str| format!("fn {name}() -> &'static str {{ \"{string}\" }}\n");
|
||||
let original = format!("{}{}", comments("tok"), code("tok", "tok"));
|
||||
let cases = [
|
||||
(C::Any, format!("{}{}", comments("X"), code("X", "X"))),
|
||||
(C::InComments, format!("{}{}", comments("X"), code("tok", "tok"))),
|
||||
(C::InStringLiterals, format!("{}{}", comments("tok"), code("tok", "X"))),
|
||||
(C::ExceptComments, format!("{}{}", comments("tok"), code("X", "X"))),
|
||||
(C::ExceptStringLiterals, format!("{}{}", comments("X"), code("X", "tok"))),
|
||||
(C::ExceptCommentsAndStringLiterals, format!("{}{}", comments("tok"), code("X", "tok"))),
|
||||
];
|
||||
for (context, expected) in cases {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let root = base.join("project");
|
||||
std::fs::create_dir_all(&root).unwrap();
|
||||
std::fs::write(root.join("lib.rs"), &original).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(&root, true, false).unwrap();
|
||||
host.open_project("main", &root).unwrap();
|
||||
ops::search::replace_in_files(
|
||||
&host,
|
||||
"main",
|
||||
RequestId::next(),
|
||||
SearchQuery { context, ..query("tok", false) },
|
||||
"X".into(),
|
||||
false,
|
||||
vec![],
|
||||
true,
|
||||
ops::Channel::new(|_| {}),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(std::fs::read_to_string(root.join("lib.rs")).unwrap(), expected, "{context:?}");
|
||||
host.close_project("main");
|
||||
}
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
@@ -199,9 +199,7 @@ async fn python_effective_interpreter_falls_back_to_the_primary_project() {
|
||||
host.trust.decide(&member, true, false).unwrap();
|
||||
host.open_project("main", &primary).unwrap();
|
||||
let python = |near: Option<&std::path::Path>| {
|
||||
futures::executor::block_on(ops::sdk::sdk_python_effective(&host, "main", near.map(|p| p.to_path_buf())))
|
||||
.unwrap()
|
||||
.map(|p| p.into_path_buf())
|
||||
ops::sdk::sdk_python_effective(&host, "main", near.map(|p| p.to_path_buf())).unwrap().map(|p| p.into_path_buf())
|
||||
};
|
||||
// The primary project's own virtualenv, and the bare member inheriting it.
|
||||
assert_eq!(python(Some(&primary)), Some(venv_python.clone()));
|
||||
@@ -219,13 +217,6 @@ async fn python_effective_interpreter_falls_back_to_the_primary_project() {
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(python(Some(&member.join("src"))), Some(configured));
|
||||
// A workspace file that fails to load (a corrupt one, say) falls back to the
|
||||
// primary project's interpreter instead of failing the whole command.
|
||||
let workspace_file = primary.join(ide_workspace::workspace::FILE);
|
||||
let valid = std::fs::read(&workspace_file).unwrap();
|
||||
std::fs::write(&workspace_file, b"{not json").unwrap();
|
||||
assert_eq!(python(Some(&member.join("src"))), Some(venv_python.clone()));
|
||||
std::fs::write(&workspace_file, valid).unwrap();
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
|
||||
@@ -15,8 +15,6 @@ tokio.workspace = true
|
||||
tracing.workspace = true
|
||||
parking_lot.workspace = true
|
||||
reqwest.workspace = true
|
||||
# The system proxy reqwest reads, to notice when it changes (see `client::shared`).
|
||||
hyper-util = { version = "0.1", default-features = false, features = ["client-proxy", "client-proxy-system"] }
|
||||
rustls.workspace = true
|
||||
rustls-platform-verifier.workspace = true
|
||||
uuid.workspace = true
|
||||
|
||||
@@ -5,7 +5,7 @@ use ide_core::proxy_settings::{ProxyMode, ProxyRoute, ProxySettings};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use parking_lot::Mutex;
|
||||
use std::sync::Arc;
|
||||
use std::time::{Duration, Instant};
|
||||
use std::time::Duration;
|
||||
|
||||
/// `builder` routed as `proxy` says: direct, the environment's proxy (reqwest's
|
||||
/// default), or the manual proxy except for the "No proxy for" hosts.
|
||||
@@ -62,61 +62,33 @@ pub fn build_with_redirect(proxy: &ProxySettings, redirect: reqwest::redirect::P
|
||||
with_proxy(builder, proxy).build().map_err(|e| fail(e.to_string()))
|
||||
}
|
||||
|
||||
/// A client built for these proxy settings and, in Auto mode, this system proxy.
|
||||
struct Cached {
|
||||
settings: Arc<ProxySettings>,
|
||||
system: Option<String>,
|
||||
client: reqwest::Client,
|
||||
}
|
||||
|
||||
/// The client for the current proxy settings, rebuilt when they change.
|
||||
pub fn shared() -> IdeResult<reqwest::Client> {
|
||||
static CLIENT: Mutex<Option<Cached>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, build, system_proxy)
|
||||
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, build)
|
||||
}
|
||||
|
||||
/// The client the HTTP Client executes requests with: redirects off, `exec`
|
||||
/// follows them by hand — that is what lets a `POST` stay a `POST` on a
|
||||
/// 301/302 and puts the redirect chain into the response.
|
||||
pub fn shared_without_redirects() -> IdeResult<reqwest::Client> {
|
||||
static CLIENT: Mutex<Option<Cached>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, |proxy| build_with_redirect(proxy, reqwest::redirect::Policy::none()), system_proxy)
|
||||
}
|
||||
|
||||
/// The system proxy (the environment's, then macOS / Windows settings) as reqwest reads
|
||||
/// it when a client is built, re-read at most every few seconds. A client in Auto mode
|
||||
/// keeps the proxy it was built with, so a proxy app that switches the system proxy on
|
||||
/// after launch would otherwise leave downloads going direct until a restart.
|
||||
fn system_proxy() -> String {
|
||||
static LAST: Mutex<Option<(Instant, String)>> = Mutex::new(None);
|
||||
let mut last = LAST.lock();
|
||||
if let Some((at, seen)) = last.as_ref()
|
||||
&& at.elapsed() < Duration::from_secs(3)
|
||||
{
|
||||
return seen.clone();
|
||||
}
|
||||
// Credentials are left out of the matcher's `Debug`.
|
||||
let seen = format!("{:?}", hyper_util::client::proxy::matcher::Matcher::from_system());
|
||||
*last = Some((Instant::now(), seen.clone()));
|
||||
seen
|
||||
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, |proxy| build_with_redirect(proxy, reqwest::redirect::Policy::none()))
|
||||
}
|
||||
|
||||
fn cached_client(
|
||||
slot: &Mutex<Option<Cached>>,
|
||||
build: impl Fn(&ProxySettings) -> IdeResult<reqwest::Client>,
|
||||
system: fn() -> String,
|
||||
slot: &Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>>,
|
||||
build: fn(&ProxySettings) -> IdeResult<reqwest::Client>,
|
||||
) -> IdeResult<reqwest::Client> {
|
||||
let proxy = ide_core::proxy_settings::proxy();
|
||||
let system = (proxy.mode == ProxyMode::Auto).then(system);
|
||||
let mut cached = slot.lock();
|
||||
if let Some(c) = cached.as_ref()
|
||||
&& *c.settings == *proxy
|
||||
&& c.system == system
|
||||
if let Some((settings, client)) = cached.as_ref()
|
||||
&& **settings == *proxy
|
||||
{
|
||||
return Ok(c.client.clone());
|
||||
return Ok(client.clone());
|
||||
}
|
||||
let client = build(&proxy)?;
|
||||
*cached = Some(Cached { settings: proxy, system, client: client.clone() });
|
||||
*cached = Some((proxy, client.clone()));
|
||||
Ok(client)
|
||||
}
|
||||
|
||||
@@ -170,36 +142,6 @@ pub fn describe(e: &reqwest::Error) -> String {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn auto_mode_rebuilds_the_shared_client_when_the_system_proxy_changes() {
|
||||
static SYSTEM: Mutex<String> = Mutex::new(String::new());
|
||||
static BUILDS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||||
fn system() -> String {
|
||||
SYSTEM.lock().clone()
|
||||
}
|
||||
let slot = Mutex::new(None);
|
||||
let get = || {
|
||||
cached_client(
|
||||
&slot,
|
||||
|proxy| {
|
||||
BUILDS.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
||||
build(proxy)
|
||||
},
|
||||
system,
|
||||
)
|
||||
.unwrap()
|
||||
};
|
||||
assert_eq!(ide_core::proxy_settings::proxy().mode, ProxyMode::Auto);
|
||||
get();
|
||||
get();
|
||||
assert_eq!(BUILDS.load(std::sync::atomic::Ordering::SeqCst), 1);
|
||||
// A proxy app switches the system proxy on after launch.
|
||||
*SYSTEM.lock() = "Matcher { https: 127.0.0.1:7890 }".into();
|
||||
get();
|
||||
get();
|
||||
assert_eq!(BUILDS.load(std::sync::atomic::Ordering::SeqCst), 2);
|
||||
}
|
||||
use ide_core::proxy_settings::ProxyKind;
|
||||
use std::io::{BufRead, BufReader, Write};
|
||||
use std::net::TcpListener;
|
||||
|
||||
@@ -265,7 +265,7 @@ impl ProjectIndex {
|
||||
pub fn find_files(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
let recent = self.shared.recent.lock().clone();
|
||||
let d = self.shared.data.read();
|
||||
matching::find_files(&d, &matching::Recents::new(&recent), query, Some(&self.root), limit)
|
||||
matching::find_files(&d, &matching::Recents::new(&recent), query, limit)
|
||||
}
|
||||
|
||||
/// All indexed files with this exact basename, for resolving printed source locations.
|
||||
@@ -301,7 +301,7 @@ impl ProjectIndex {
|
||||
|
||||
/// Fuzzy search for folders that hold indexed files; `rel_path` ends in `/`.
|
||||
pub fn find_dirs(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
matching::find_dirs(&self.shared.data.read(), query, Some(&self.root), limit)
|
||||
matching::find_dirs(&self.shared.data.read(), query, limit)
|
||||
}
|
||||
|
||||
/// Fuzzy symbol search; CamelHump aware (`OCo` → `OrderController`).
|
||||
@@ -574,11 +574,11 @@ pub mod bench_support {
|
||||
}
|
||||
|
||||
pub fn find_files(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
matching::find_files(&self.data, &matching::Recents::new(&self.recent), query, None, limit)
|
||||
matching::find_files(&self.data, &matching::Recents::new(&self.recent), query, limit)
|
||||
}
|
||||
|
||||
pub fn find_dirs(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
matching::find_dirs(&self.data, query, None, limit)
|
||||
matching::find_dirs(&self.data, query, limit)
|
||||
}
|
||||
|
||||
pub fn find_symbols(&self, query: &str, filter: SymbolFilter, limit: usize) -> Vec<SymbolMatch> {
|
||||
|
||||
@@ -205,67 +205,29 @@ impl<'a> Recents<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
/// `Foo.kt:12:3` -> `Foo.kt`; `\` -> `/`; a pasted absolute path under `root` -> its project-relative
|
||||
/// form; strips leading `./` and `/`.
|
||||
fn normalize_file_query(q: &str, root: Option<&Path>) -> String {
|
||||
/// `Foo.kt:12:3` -> `Foo.kt`; `\` -> `/`; strips leading `./` and `/`.
|
||||
fn normalize_file_query(q: &str) -> String {
|
||||
let mut q = q.trim().replace('\\', "/");
|
||||
// `\\?\C:\a` (verbatim) and `\\.\C:\a` name `C:/a`.
|
||||
if let Some(rest) = verbatim_target(&q) {
|
||||
q = rest.to_owned();
|
||||
}
|
||||
while let Some((head, tail)) = q.rsplit_once(':')
|
||||
&& !tail.is_empty()
|
||||
&& tail.bytes().all(|b| b.is_ascii_digit())
|
||||
{
|
||||
q = head.to_owned();
|
||||
}
|
||||
if let Some(root) = root
|
||||
&& let Some(rel) = strip_root(&q, root)
|
||||
{
|
||||
q = rel;
|
||||
}
|
||||
let q = q.trim_start_matches("./").trim_start_matches('/');
|
||||
q.chars().filter(|c| !c.is_whitespace()).collect()
|
||||
}
|
||||
|
||||
/// Path a `\\?\` / `\\.\` verbatim prefix points at, for a `/`-separated path.
|
||||
fn verbatim_target(q: &str) -> Option<&str> {
|
||||
q.strip_prefix("//?/").or_else(|| q.strip_prefix("//./"))
|
||||
}
|
||||
|
||||
/// `q` (already `/`-separated) below `root`, without the separating slash. A drive-letter root
|
||||
/// compares like Windows, where case does not matter.
|
||||
fn strip_root(q: &str, root: &Path) -> Option<String> {
|
||||
let root = root.to_string_lossy().replace('\\', "/");
|
||||
let root = verbatim_target(&root).unwrap_or(&root);
|
||||
let root = root.trim_end_matches('/');
|
||||
let windows = root.as_bytes().get(1) == Some(&b':');
|
||||
let head = q.get(..root.len())?;
|
||||
if head != root && !(windows && head.eq_ignore_ascii_case(root)) {
|
||||
return None;
|
||||
}
|
||||
match q.get(root.len()..)? {
|
||||
"" => Some(String::new()),
|
||||
tail => tail.strip_prefix('/').map(str::to_owned),
|
||||
}
|
||||
}
|
||||
|
||||
enum FileQuery {
|
||||
Name(Needle),
|
||||
Path { dir: Needle, name: Needle },
|
||||
}
|
||||
|
||||
pub(crate) fn find_files(
|
||||
data: &IndexData,
|
||||
recents: &Recents,
|
||||
query: &str,
|
||||
root: Option<&Path>,
|
||||
limit: usize,
|
||||
) -> Vec<FileMatch> {
|
||||
pub(crate) fn find_files(data: &IndexData, recents: &Recents, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
if limit == 0 {
|
||||
return Vec::new();
|
||||
}
|
||||
let q = normalize_file_query(query, root);
|
||||
let q = normalize_file_query(query);
|
||||
if q.is_empty() {
|
||||
return recents
|
||||
.paths
|
||||
@@ -344,8 +306,8 @@ pub(crate) fn find_files(
|
||||
|
||||
/// Fuzzy folder search over the folders holding indexed files: folder-name matches beat
|
||||
/// path matches; `/` in the query matches the whole path. `rel_path` ends in `/`.
|
||||
pub(crate) fn find_dirs(data: &IndexData, query: &str, root: Option<&Path>, limit: usize) -> Vec<FileMatch> {
|
||||
let q = normalize_file_query(query, root);
|
||||
pub(crate) fn find_dirs(data: &IndexData, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
let q = normalize_file_query(query);
|
||||
if limit == 0 || q.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
@@ -711,18 +673,8 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn normalizes_queries() {
|
||||
let root = Path::new("E:/work/sample");
|
||||
assert_eq!(normalize_file_query(" ./src\\main.rs:12:4 ", None), "src/main.rs");
|
||||
assert_eq!(normalize_file_query("/a b", None), "ab");
|
||||
// A pasted absolute path names an indexed file (#4079 follow-up).
|
||||
assert_eq!(normalize_file_query(r"E:\work\sample\pkg\Config.go", Some(root)), "pkg/Config.go");
|
||||
assert_eq!(normalize_file_query(r"e:/WORK/sample\pkg/Config.go", Some(root)), "pkg/Config.go");
|
||||
assert_eq!(normalize_file_query(r"\\?\E:\work\sample\src\App.kt", Some(root)), "src/App.kt");
|
||||
assert_eq!(normalize_file_query(r"E:\work\sample\pkg\Config.go:12:4", Some(root)), "pkg/Config.go");
|
||||
// Outside the project, and a POSIX root, keep the path as given.
|
||||
assert_eq!(normalize_file_query(r"E:\elsewhere\x.go", Some(root)), "E:/elsewhere/x.go");
|
||||
assert_eq!(normalize_file_query("/home/me/Src/a.rs", Some(Path::new("/home/me/src"))), "home/me/Src/a.rs");
|
||||
assert_eq!(normalize_file_query("/home/me/src/a.rs", Some(Path::new("/home/me/src"))), "a.rs");
|
||||
assert_eq!(normalize_file_query(" ./src\\main.rs:12:4 "), "src/main.rs");
|
||||
assert_eq!(normalize_file_query("/a b"), "ab");
|
||||
assert_eq!(split_symbol_query("Order.save"), (Some("Order"), "save"));
|
||||
assert_eq!(split_symbol_query("a::b::C::new"), (Some("C"), "new"));
|
||||
assert_eq!(split_symbol_query("save"), (None, "save"));
|
||||
|
||||
@@ -13,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 = {
|
||||
|
||||
@@ -190,19 +190,6 @@ fn file_ranking_is_idea_like() {
|
||||
assert_eq!(shown.to_lowercase(), "uibtn");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_pasted_absolute_path_finds_the_indexed_file() {
|
||||
let fx = sample();
|
||||
let idx = fx.open();
|
||||
let abs = fx.root.join("src/ui/Button.tsx");
|
||||
let abs = abs.to_string_lossy().into_owned();
|
||||
assert_eq!(files(&idx, &abs)[0], "src/ui/Button.tsx");
|
||||
// A trailing `:line:col`, and a path outside the project that names no file.
|
||||
assert_eq!(files(&idx, &format!("{abs}:12:4"))[0], "src/ui/Button.tsx");
|
||||
let outside = fx.root.parent().unwrap().join("elsewhere/Button.tsx");
|
||||
assert!(files(&idx, &outside.to_string_lossy()).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn find_dirs_ranks_folder_names() {
|
||||
let f = sample();
|
||||
|
||||
@@ -472,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> {
|
||||
|
||||
@@ -25,7 +25,7 @@ pub use syntax::{
|
||||
CSS_CLASS, CSS_ID, CSS_VARIABLE, ClassBases, ConfigurationKey, ExternalFold, ExternalSymbol, ExternalSyntax,
|
||||
ExternalToken, FileReference, Literal, LiteralKind, MAX_CACHED_TREES, MAX_PARSE_BYTES, ParsedTree, SpellingKind,
|
||||
SpellingRegion, Syntax, SyntaxCache, SyntaxCacheStats, SyntaxHighlightKind, SyntaxHighlights, TreeError,
|
||||
VueComponentImport, VueRefAccess, VueRefElement, WebReference, WebReferenceKind, merge_kinds, merge_visibility,
|
||||
VueComponentImport, VueRefAccess, VueRefElement, WebReference, WebReferenceKind, merge_visibility,
|
||||
set_external_syntax, shift_pos, shift_range,
|
||||
};
|
||||
pub use syntax::{MethodBody, PhpAlignment, PythonClassFacts, PythonFacts, PythonMethodFacts};
|
||||
@@ -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>,
|
||||
|
||||
@@ -28,7 +28,7 @@ use ide_core::{LanguageId, OutlineItem, Pos, Range};
|
||||
pub use inheritance::ClassBases;
|
||||
pub use lines::{shift_pos, shift_range};
|
||||
pub use literals::{Literal, LiteralKind, SpellingKind, SpellingRegion};
|
||||
pub use outline::{merge_kinds, merge_visibility};
|
||||
pub use outline::merge_visibility;
|
||||
pub use php_align::PhpAlignment;
|
||||
pub use python_facts::{MethodBody, PythonClassFacts, PythonFacts, PythonMethodFacts};
|
||||
use std::cell::RefCell;
|
||||
|
||||
@@ -495,36 +495,6 @@ pub fn merge_visibility(target: &mut [OutlineItem], source: &[OutlineItem]) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Takes the syntax tree's kind where a server reported a declared type as a value or a type
|
||||
/// parameter: LSP has no kind for type aliases, so servers fall back to one of those
|
||||
/// (typescript-language-server: Variable; rust-analyzer, sourcekit-lsp: TypeParameter).
|
||||
/// Matched by name and position like [`merge_visibility`].
|
||||
pub fn merge_kinds(target: &mut [OutlineItem], source: &[OutlineItem]) {
|
||||
fn index(items: &[OutlineItem], out: &mut HashMap<(ide_core::Pos, String), SymbolKind>) {
|
||||
for i in items {
|
||||
if i.kind.is_type_like() {
|
||||
out.insert((i.selection_range.start, i.name.clone()), i.kind);
|
||||
}
|
||||
index(&i.children, out);
|
||||
}
|
||||
}
|
||||
fn apply(items: &mut [OutlineItem], map: &HashMap<(ide_core::Pos, String), SymbolKind>) {
|
||||
for i in items {
|
||||
if matches!(i.kind, SymbolKind::Variable | SymbolKind::TypeParameter)
|
||||
&& let Some(&kind) = map.get(&(i.selection_range.start, i.name.clone()))
|
||||
{
|
||||
i.kind = kind;
|
||||
}
|
||||
apply(&mut i.children, map);
|
||||
}
|
||||
}
|
||||
let mut map = HashMap::new();
|
||||
index(source, &mut map);
|
||||
if !map.is_empty() {
|
||||
apply(target, &map);
|
||||
}
|
||||
}
|
||||
|
||||
/// End of `node` without trailing whitespace (C macros and others include the newline).
|
||||
fn trimmed_end(node: &Node, text: &str) -> usize {
|
||||
let (s, e) = (node.start_byte(), node.end_byte());
|
||||
|
||||
@@ -1476,88 +1476,6 @@ fn merge_visibility_matches_by_name_and_position() {
|
||||
assert_eq!(lsp[1].visibility, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn merge_kinds_names_types_a_server_reported_as_values_or_type_parameters() {
|
||||
fn kinds(items: &[OutlineItem], out: &mut Vec<(String, SymbolKind)>) {
|
||||
for i in items {
|
||||
out.push((i.name.clone(), i.kind));
|
||||
kinds(&i.children, out);
|
||||
}
|
||||
}
|
||||
/// The syntax outline with each kind replaced as a server reports it.
|
||||
fn as_server(ts: &[OutlineItem], server: &[(&str, SymbolKind)]) -> Vec<OutlineItem> {
|
||||
fn set(items: &mut [OutlineItem], server: &[(&str, SymbolKind)], at: &mut usize) {
|
||||
for i in items {
|
||||
i.kind = server[*at].1;
|
||||
assert_eq!(i.name, server[*at].0);
|
||||
*at += 1;
|
||||
set(&mut i.children, server, at);
|
||||
}
|
||||
}
|
||||
let mut lsp = ts.to_vec();
|
||||
set(&mut lsp, server, &mut 0);
|
||||
lsp
|
||||
}
|
||||
fn merged(language: &str, src: &str, server: &[(&str, SymbolKind)]) -> Vec<(String, SymbolKind)> {
|
||||
let ts = syntax().outline(&lang(language), src);
|
||||
let mut lsp = as_server(&ts, server);
|
||||
crate::merge_kinds(&mut lsp, &ts);
|
||||
let mut out = Vec::new();
|
||||
kinds(&lsp, &mut out);
|
||||
out
|
||||
}
|
||||
use SymbolKind as K;
|
||||
let owned = |v: &[(&str, SymbolKind)]| v.iter().map(|(n, k)| (n.to_string(), *k)).collect::<Vec<_>>();
|
||||
|
||||
// typescript-language-server: a type alias is a Variable; `const` is one too.
|
||||
let ts = "type Cents = number;\ninterface Shape {}\nconst rate = 1;\n";
|
||||
assert_eq!(
|
||||
merged("typescript", ts, &[("Cents", K::Variable), ("Shape", K::Interface), ("rate", K::Variable)]),
|
||||
owned(&[("Cents", K::TypeAlias), ("Shape", K::Interface), ("rate", K::Variable)]),
|
||||
);
|
||||
|
||||
// rust-analyzer: type aliases and associated types are TypeParameters, a trait an Interface.
|
||||
let rs = "pub type Meters = u32;\ntrait Measure { type Unit; }\nstruct Rope;\nimpl Measure for Rope { type Unit = Meters; }\n";
|
||||
assert_eq!(
|
||||
merged(
|
||||
"rust",
|
||||
rs,
|
||||
&[
|
||||
("Meters", K::TypeParameter),
|
||||
("Measure", K::Interface),
|
||||
("Unit", K::TypeParameter),
|
||||
("Rope", K::Struct),
|
||||
("impl Measure for Rope", K::Variable),
|
||||
("Unit", K::TypeParameter),
|
||||
],
|
||||
),
|
||||
owned(&[
|
||||
("Meters", K::TypeAlias),
|
||||
("Measure", K::Interface),
|
||||
("Unit", K::TypeAlias),
|
||||
("Rope", K::Struct),
|
||||
("impl Measure for Rope", K::Variable),
|
||||
("Unit", K::TypeAlias),
|
||||
]),
|
||||
);
|
||||
|
||||
// sourcekit-lsp: typealias and associatedtype are TypeParameters.
|
||||
let swift = "typealias Meters = Int\nprotocol Measure { associatedtype Unit }\n";
|
||||
assert_eq!(
|
||||
merged("swift", swift, &[("Meters", K::TypeParameter), ("Measure", K::Interface), ("Unit", K::TypeParameter)]),
|
||||
owned(&[("Meters", K::TypeAlias), ("Measure", K::Interface), ("Unit", K::TypeAlias)]),
|
||||
);
|
||||
|
||||
// A type kind the server chose stays: clangd's Class for a typedef, gopls's Struct.
|
||||
let c = "typedef unsigned int meters;\n";
|
||||
assert_eq!(merged("c", c, &[("meters", K::Class)]), owned(&[("meters", K::Class)]));
|
||||
let go = "package p\n\ntype Point struct{}\n";
|
||||
assert_eq!(
|
||||
merged("go", go, &[("p", K::Package), ("Point", K::Struct)]),
|
||||
owned(&[("p", K::Package), ("Point", K::Struct)])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn spelling_regions_cover_declared_names_only() {
|
||||
let src = "// note\nfn parse_input(raw_text: &str) -> Value { let mut counter = helper(raw_text); \"hi\" }\n";
|
||||
|
||||
@@ -25,17 +25,6 @@ const PROGRESS_SWEEP: Duration = Duration::from_secs(15);
|
||||
/// visible, but stops holding the server busy while the work behind it keeps running.
|
||||
const PROGRESS_STALE: Duration = Duration::from_secs(180);
|
||||
|
||||
/// How long a cancelled progress task waits for its server to end it.
|
||||
const CANCEL_GRACE: Duration = Duration::from_secs(5);
|
||||
|
||||
/// The key of progress token `token` in [`Server::progress`].
|
||||
fn progress_key(token: &Value) -> String {
|
||||
match token {
|
||||
Value::String(s) => s.clone(),
|
||||
other => other.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Task message after [`PROGRESS_STALE`] of silence: keep the server's last message and
|
||||
/// say how long nothing happened.
|
||||
fn stalled_message(message: Option<&str>) -> String {
|
||||
@@ -108,50 +97,22 @@ impl ClientHandler {
|
||||
}
|
||||
|
||||
/// Cancelling task `task` asks this server instance to stop the work of progress `token`.
|
||||
/// A server that never ends it (Pyright waiting on a workspace that never loads) would
|
||||
/// leave the task "Cancelling…" for good: after [`CANCEL_GRACE`] the task ends here.
|
||||
fn cancel_handle(&self, task: TaskId, token: &Value) -> ide_core::task::CancelHandle {
|
||||
let (mgr, server, generation, token) = (self.mgr.clone(), self.server.clone(), self.generation, token.clone());
|
||||
let (server, generation, token) = (self.server.clone(), self.generation, token.clone());
|
||||
ide_core::task::on_cancel(task, move || {
|
||||
if let Some(run) = server.initialized_gen(generation)
|
||||
&& let Err(e) = run.peer.notify("window/workDoneProgress/cancel", json!({ "token": token }))
|
||||
{
|
||||
tracing::debug!("{}: cannot cancel progress: {e}", server.name);
|
||||
}
|
||||
let Some(runtime) = mgr.upgrade().map(|m| m.runtime.clone()) else { return };
|
||||
runtime.spawn(async move {
|
||||
tokio::time::sleep(CANCEL_GRACE).await;
|
||||
let Some(mgr) = mgr.upgrade() else { return };
|
||||
let key = progress_key(&token);
|
||||
let ended = {
|
||||
let mut progress = server.progress.lock();
|
||||
if progress.get(&key).is_none_or(|p| p.task != task) {
|
||||
return; // the server ended it, or the token began new work
|
||||
}
|
||||
progress.remove(&key)
|
||||
};
|
||||
if let Some(p) = ended {
|
||||
tracing::info!("{}: progress '{key}' did not end after cancel; ending its task", server.name);
|
||||
server.emit(
|
||||
mgr.sink(),
|
||||
IdeEvent::Task {
|
||||
id: p.task,
|
||||
title: p.title,
|
||||
message: p.message,
|
||||
fraction: None,
|
||||
done: true,
|
||||
cancellable: false,
|
||||
},
|
||||
);
|
||||
server.refresh_busy_status(mgr.sink());
|
||||
server.progress_ended();
|
||||
}
|
||||
});
|
||||
})
|
||||
}
|
||||
|
||||
fn progress(&self, mgr: &LspManager, params: Value) {
|
||||
let token = progress_key(¶ms["token"]);
|
||||
let token = match ¶ms["token"] {
|
||||
Value::String(s) => s.clone(),
|
||||
other => other.to_string(),
|
||||
};
|
||||
let value = ¶ms["value"];
|
||||
let kind = value.get("kind").and_then(Value::as_str);
|
||||
let message = value.get("message").and_then(Value::as_str).map(str::to_owned);
|
||||
|
||||
@@ -25,7 +25,7 @@ impl LspManager {
|
||||
/// Whether jdtls serves the Java files of `path`. Without it, launches build with the
|
||||
/// build tool and take the classpath from [`Self::java_server_classpath`] or the build model.
|
||||
pub fn java_served_by_jdtls(&self, path: &Path) -> bool {
|
||||
self.servers_for(&LanguageId::new("java"), path).iter().any(|s| s.name == JDTLS && !s.gave_up())
|
||||
self.servers_for(&LanguageId::new("java"), path).iter().any(|s| s.name == JDTLS)
|
||||
}
|
||||
|
||||
/// The java-analyzer executable among the Java servers of `path`, whatever the server is
|
||||
@@ -107,27 +107,6 @@ fn is_java_analyzer(binary: &Path) -> bool {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::server::Conn;
|
||||
use ide_core::event::ServerStatus;
|
||||
use ide_language::LanguageRegistry;
|
||||
use std::sync::Arc;
|
||||
|
||||
#[test]
|
||||
fn missing_jdtls_leaves_java_analyzer_to_serve_the_module() {
|
||||
let project = tempfile::tempdir().unwrap();
|
||||
let root = project.path();
|
||||
let manager =
|
||||
LspManager::new(root.to_path_buf(), Arc::new(LanguageRegistry::load(None).unwrap()), Arc::new(|_| {}));
|
||||
assert!(manager.java_served_by_jdtls(root));
|
||||
assert!(manager.java_analyzer_binary(root).is_none());
|
||||
|
||||
let jdtls = manager.servers_for(&LanguageId::new("java"), root).into_iter().find(|s| s.name == JDTLS).unwrap();
|
||||
let generation = jdtls.begin_start().unwrap();
|
||||
assert!(jdtls.fail_start(generation, Conn::Missing, manager.sink(), ServerStatus::Missing, None));
|
||||
|
||||
assert!(!manager.java_served_by_jdtls(root));
|
||||
assert_eq!(manager.java_analyzer_binary(root).as_deref(), Some(Path::new("java-analyzer")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recognises_java_analyzer_by_its_executable() {
|
||||
|
||||
@@ -1049,14 +1049,12 @@ impl LspManager {
|
||||
if let Err(e) = peer.notify("initialized", json!({})) {
|
||||
tracing::warn!("{}: {e}", server.name);
|
||||
}
|
||||
// Sent even without settings: servers that don't ask with `workspace/configuration`
|
||||
// only learn settings this way, and Pyright, given workspace folders, waits for it
|
||||
// before asking and loading the workspace.
|
||||
let mut settings = handler::all_settings(&server.effective_config());
|
||||
if settings.is_null() {
|
||||
settings = json!({});
|
||||
}
|
||||
if let Err(e) = peer.notify("workspace/didChangeConfiguration", json!({ "settings": settings })) {
|
||||
// Servers that don't ask with `workspace/configuration` only learn settings this way.
|
||||
let cfg = server.effective_config();
|
||||
if cfg.settings.is_some()
|
||||
&& let Err(e) =
|
||||
peer.notify("workspace/didChangeConfiguration", json!({ "settings": handler::all_settings(&cfg) }))
|
||||
{
|
||||
tracing::debug!("{}: didChangeConfiguration: {e}", server.name);
|
||||
}
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
use ide_core::event::{LspRefreshKind, ServerStatus};
|
||||
use ide_core::{
|
||||
CancellationToken, DocId, FileEdit, IdeEvent, LanguageId, Pos, Range, ServerId, Severity, TaskId, WorkspaceEdit,
|
||||
CancellationToken, DocId, FileEdit, IdeEvent, LanguageId, Pos, Range, ServerId, Severity, WorkspaceEdit,
|
||||
};
|
||||
use ide_jsonrpc::{Handler, NoopHandler, Peer};
|
||||
use ide_language::{LanguageConfig, LanguageRegistry, LanguageServerConfig};
|
||||
@@ -1324,36 +1324,6 @@ async fn initialize_and_incremental_sync() {
|
||||
assert_eq!(infos[0].status, ServerStatus::Ready);
|
||||
}
|
||||
|
||||
/// Pyright, told the client has workspace folders, asks for its configuration and loads the
|
||||
/// workspace only after a `workspace/didChangeConfiguration`: every server gets one at startup.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn every_server_hears_its_configuration_once_initialized() {
|
||||
let cases = [
|
||||
(None, None, json!({})),
|
||||
(Some(json!({ "flag": true })), None, json!({ "flag": true })),
|
||||
(
|
||||
None,
|
||||
Some(json!({ "python": { "pythonPath": "/venv/bin/python" } })),
|
||||
json!({ "python": { "pythonPath": "/venv/bin/python" } }),
|
||||
),
|
||||
(Some(json!({ "flag": true })), Some(json!({ "other": 2 })), json!({ "flag": true, "other": 2 })),
|
||||
];
|
||||
for (init, settings, expected) in cases {
|
||||
let h = harness_configured("mock", "mk", &[("pyright", incremental_caps())], |cfg| {
|
||||
cfg.initialization_options = init.clone().map(|v| toml::Value::try_from(v).unwrap());
|
||||
cfg.settings = settings.clone();
|
||||
});
|
||||
h.open("a.mk", "x");
|
||||
h.wait_status("pyright", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("pyright");
|
||||
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
|
||||
assert_eq!(s.notified("workspace/didChangeConfiguration"), vec![json!({ "settings": expected })]);
|
||||
let order: Vec<String> = s.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
|
||||
let at = |m: &str| order.iter().position(|n| n == m).unwrap();
|
||||
assert!(at("initialized") < at("workspace/didChangeConfiguration"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn full_sync_and_desync_recovery() {
|
||||
let h = harness(&[("full", json!({ "textDocumentSync": 1 })), ("inc", json!({ "textDocumentSync": 2 }))]);
|
||||
@@ -2182,51 +2152,6 @@ async fn replacing_progress_keeps_cancellation_reports_and_indexing_on_the_new_t
|
||||
);
|
||||
}
|
||||
|
||||
/// A server that ignores `window/workDoneProgress/cancel` (Pyright waiting on a workspace
|
||||
/// that never loads) does not keep the task "Cancelling…": it ends after a grace period,
|
||||
/// once, and later reports on the token change nothing. A server that ends it in time ends it.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_cancelled_progress_the_server_never_ends_ends_on_its_own() {
|
||||
let h = harness(&[("mock", incremental_caps())]);
|
||||
h.open("a.mk", "x");
|
||||
h.wait_status("mock", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("mock");
|
||||
let peer = s.peer();
|
||||
let begin = |token: &str, title: &str| json!({ "token": token, "value": { "kind": "begin", "title": title, "cancellable": true } });
|
||||
let task_of = |title: &str| {
|
||||
h.events.lock().iter().find_map(|e| match e {
|
||||
IdeEvent::Task { id, title: t, done: false, .. } if t == title => Some(*id),
|
||||
_ => None,
|
||||
})
|
||||
};
|
||||
let ends = |task: TaskId| {
|
||||
h.events.lock().iter().filter(|e| matches!(e, IdeEvent::Task { id, done: true, .. } if *id == task)).count()
|
||||
};
|
||||
peer.notify("$/progress", begin("ignored", "Finding references")).unwrap();
|
||||
peer.notify("$/progress", begin("honoured", "Indexing")).unwrap();
|
||||
eventually(|| task_of("Finding references").is_some() && task_of("Indexing").is_some()).await;
|
||||
h.wait_status("mock", ServerStatus::Busy).await;
|
||||
let (ignored, honoured) = (task_of("Finding references").unwrap(), task_of("Indexing").unwrap());
|
||||
|
||||
assert!(ide_core::task::cancel(ignored));
|
||||
assert!(ide_core::task::cancel(honoured));
|
||||
eventually(|| s.notified("window/workDoneProgress/cancel").len() == 2).await;
|
||||
peer.notify("$/progress", json!({ "token": "honoured", "value": { "kind": "end" } })).unwrap();
|
||||
eventually(|| ends(honoured) == 1).await;
|
||||
assert_eq!(ends(ignored), 0, "the server still has its grace period");
|
||||
|
||||
eventually(|| ends(ignored) == 1).await;
|
||||
h.wait_status("mock", ServerStatus::Ready).await;
|
||||
// Late reports on the token reach no task.
|
||||
peer.notify("$/progress", json!({ "token": "ignored", "value": { "kind": "report", "message": "late" } })).unwrap();
|
||||
peer.notify("$/progress", json!({ "token": "ignored", "value": { "kind": "end" } })).unwrap();
|
||||
peer.notify("$/progress", begin("after", "After")).unwrap();
|
||||
eventually(|| task_of("After").is_some()).await;
|
||||
assert_eq!(ends(ignored), 1);
|
||||
assert_eq!(ends(honoured), 1);
|
||||
assert!(!h.events.lock().iter().any(|e| matches!(e, IdeEvent::Task { message: Some(m), .. } if m == "late")));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn cancelling_a_cancellable_progress_task_asks_the_server_to_stop() {
|
||||
let h = harness(&[("mock", incremental_caps())]);
|
||||
@@ -2725,16 +2650,7 @@ async fn configuration_answer_resyncs_open_documents_of_opted_in_servers() {
|
||||
.await;
|
||||
assert_eq!(s.notified("textDocument/didChange").len(), 2, "one re-sync per answer");
|
||||
let methods: Vec<String> = extra.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
|
||||
assert_eq!(
|
||||
methods,
|
||||
[
|
||||
"initialized",
|
||||
"workspace/didChangeConfiguration",
|
||||
"textDocument/didOpen",
|
||||
"textDocument/didChange",
|
||||
"textDocument/didSave"
|
||||
]
|
||||
);
|
||||
assert_eq!(methods, ["initialized", "textDocument/didOpen", "textDocument/didChange", "textDocument/didSave"]);
|
||||
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
@@ -2790,9 +2706,9 @@ async fn settings_changes_reach_servers_without_restarts() {
|
||||
let s = h.launcher.state("mock");
|
||||
*settings.lock() = Some(json!({ "nested": { "other": 2 } }));
|
||||
h.mgr.reconfigure().await;
|
||||
eventually(|| s.notified("workspace/didChangeConfiguration").len() == 2).await;
|
||||
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
|
||||
assert_eq!(
|
||||
s.notified("workspace/didChangeConfiguration")[1],
|
||||
s.notified("workspace/didChangeConfiguration")[0],
|
||||
json!({ "settings": { "flag": true, "nested": { "deep": 1, "other": 2 } } })
|
||||
);
|
||||
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
|
||||
|
||||
@@ -462,54 +462,35 @@ fn main() {
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires ty on PATH"]
|
||||
async fn ty_python_end_to_end() {
|
||||
python_server_end_to_end("ty").await;
|
||||
}
|
||||
|
||||
/// Pyright loads the workspace only after `workspace/didChangeConfiguration`.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires pyright-langserver on PATH"]
|
||||
async fn pyright_python_end_to_end() {
|
||||
python_server_end_to_end("pyright").await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires basedpyright on PATH"]
|
||||
async fn basedpyright_python_end_to_end() {
|
||||
python_server_end_to_end("basedpyright").await;
|
||||
}
|
||||
|
||||
/// Definition and diagnostics from `name` alone, in a project without configuration.
|
||||
async fn python_server_end_to_end(name: &str) {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path().canonicalize().unwrap();
|
||||
let path = root.join("example.py");
|
||||
let source = "def greet(name: str) -> str:\n return name\n\nresult = greet('Ada')\nbad: int = 'wrong'\n";
|
||||
std::fs::write(&path, source).unwrap();
|
||||
let mut python = LanguageRegistry::load(None).unwrap().get(&LanguageId::new("python")).unwrap();
|
||||
python.language_servers.retain(|server| server.name == name);
|
||||
python.language_servers.retain(|server| server.name == "ty");
|
||||
assert_eq!(python.language_servers.len(), 1);
|
||||
python.language_servers[0].fallback = false;
|
||||
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![python]));
|
||||
let doc = DocId::next();
|
||||
mgr.did_open(doc, &path, &LanguageId::new("python"), 1, source);
|
||||
retry(&format!("{name} ready"), Duration::from_secs(30), || {
|
||||
let status = last_status(&events, name);
|
||||
retry("ty ready", Duration::from_secs(30), || {
|
||||
let status = last_status(&events, "ty");
|
||||
if let Some((ServerStatus::Crashed | ServerStatus::Missing | ServerStatus::Misconfigured, msg)) = &status {
|
||||
panic!("{name} failed: {msg:?}");
|
||||
panic!("ty failed: {msg:?}");
|
||||
}
|
||||
async move { matches!(status, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }
|
||||
})
|
||||
.await;
|
||||
let defs = retry(&format!("{name} definition"), Duration::from_secs(30), || {
|
||||
let defs = retry("ty definition", Duration::from_secs(30), || {
|
||||
let mgr = mgr.clone();
|
||||
async move { mgr.goto(doc, Pos::new(3, 10), GotoKind::Definition).await.ok().filter(|d| !d.is_empty()) }
|
||||
})
|
||||
.await;
|
||||
assert_eq!(defs[0].path, path);
|
||||
assert_eq!(defs[0].range.start.line, 0);
|
||||
retry(&format!("{name} diagnostics"), Duration::from_secs(30), || {
|
||||
retry("ty diagnostics", Duration::from_secs(30), || {
|
||||
let found = events.lock().iter().any(
|
||||
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == name && !items.is_empty()),
|
||||
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == "ty" && !items.is_empty()),
|
||||
);
|
||||
async move { found.then_some(()) }
|
||||
})
|
||||
|
||||
@@ -349,9 +349,64 @@ impl RemoteService {
|
||||
progress: &mut (dyn FnMut(&str, usize, usize) + Send),
|
||||
) -> IdeResult<TransferReport> {
|
||||
let fs = self.fs(connection).await?;
|
||||
let r = download_into(&fs, remotes, dir, cancel, progress).await;
|
||||
let mut report = TransferReport::default();
|
||||
let mut folders = Vec::new();
|
||||
let mut jobs = Vec::new();
|
||||
for remote in remotes {
|
||||
let Some(top) = download_target(dir, remote, remote) else {
|
||||
report.skipped += 1;
|
||||
continue;
|
||||
};
|
||||
match fs.stat(remote).await {
|
||||
Ok(Some(e)) if e.is_dir => {
|
||||
folders.push(top);
|
||||
let mut entries = Vec::new();
|
||||
if let Err(e) = remote_tree(&fs, remote, cancel, &mut entries).await {
|
||||
report.fail(remote.clone(), e);
|
||||
}
|
||||
for entry in entries {
|
||||
match download_target(dir, remote, &entry.path) {
|
||||
Some(local) if entry.is_dir => folders.push(local),
|
||||
Some(local) => jobs.push((entry.path, local)),
|
||||
None => report.skipped += 1,
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(Some(_)) => jobs.push((remote.clone(), top)),
|
||||
Ok(None) => report.fail(remote.clone(), IdeError::not_found(format!("{remote} does not exist"))),
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
let root = tokio::fs::canonicalize(dir).await?;
|
||||
for folder in &folders {
|
||||
if !stays_inside(&root, folder).await {
|
||||
report.fail(folder.display().to_string(), outside(folder));
|
||||
} else if let Err(e) = tokio::fs::create_dir_all(folder).await {
|
||||
report.fail(folder.display().to_string(), e.into());
|
||||
}
|
||||
}
|
||||
for (i, (remote, local)) in jobs.iter().enumerate() {
|
||||
if cancel.is_cancelled() {
|
||||
break;
|
||||
}
|
||||
progress(remote, i, jobs.len());
|
||||
if !stays_inside(&root, local).await {
|
||||
report.fail(remote.clone(), outside(local));
|
||||
continue;
|
||||
}
|
||||
if let Some(parent) = local.parent()
|
||||
&& let Err(e) = tokio::fs::create_dir_all(parent).await
|
||||
{
|
||||
report.fail(remote.clone(), e.into());
|
||||
continue;
|
||||
}
|
||||
match fs.download(remote, local).await {
|
||||
Ok(()) => report.files += 1,
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
fs.close().await;
|
||||
r
|
||||
Ok(report)
|
||||
}
|
||||
|
||||
// --- save hook -----------------------------------------------------------------
|
||||
@@ -601,75 +656,6 @@ fn cache_key(connection: &FsConnection) -> String {
|
||||
}
|
||||
|
||||
/// Files and folders under remote folder `dir` (symlinked folders are not followed).
|
||||
/// `remotes` (folders recursively) into the local folder `dir`, each under its own name, without
|
||||
/// the remote path above it; existing files are replaced. Remote Host › Download to…, and the
|
||||
/// project view's Download to… in a remote project.
|
||||
pub async fn download_into(
|
||||
fs: &RemoteFs,
|
||||
remotes: &[String],
|
||||
dir: &Path,
|
||||
cancel: &CancellationToken,
|
||||
progress: &mut (dyn FnMut(&str, usize, usize) + Send),
|
||||
) -> IdeResult<TransferReport> {
|
||||
let mut report = TransferReport::default();
|
||||
let mut folders = Vec::new();
|
||||
let mut jobs = Vec::new();
|
||||
for remote in remotes {
|
||||
let Some(top) = download_target(dir, remote, remote) else {
|
||||
report.skipped += 1;
|
||||
continue;
|
||||
};
|
||||
match fs.stat(remote).await {
|
||||
Ok(Some(e)) if e.is_dir => {
|
||||
folders.push(top);
|
||||
let mut entries = Vec::new();
|
||||
if let Err(e) = remote_tree(fs, remote, cancel, &mut entries).await {
|
||||
report.fail(remote.clone(), e);
|
||||
}
|
||||
for entry in entries {
|
||||
match download_target(dir, remote, &entry.path) {
|
||||
Some(local) if entry.is_dir => folders.push(local),
|
||||
Some(local) => jobs.push((entry.path, local)),
|
||||
None => report.skipped += 1,
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(Some(_)) => jobs.push((remote.clone(), top)),
|
||||
Ok(None) => report.fail(remote.clone(), IdeError::not_found(format!("{remote} does not exist"))),
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
let root = tokio::fs::canonicalize(dir).await?;
|
||||
for folder in &folders {
|
||||
if !stays_inside(&root, folder).await {
|
||||
report.fail(folder.display().to_string(), outside(folder));
|
||||
} else if let Err(e) = tokio::fs::create_dir_all(folder).await {
|
||||
report.fail(folder.display().to_string(), e.into());
|
||||
}
|
||||
}
|
||||
for (i, (remote, local)) in jobs.iter().enumerate() {
|
||||
if cancel.is_cancelled() {
|
||||
break;
|
||||
}
|
||||
progress(remote, i, jobs.len());
|
||||
if !stays_inside(&root, local).await {
|
||||
report.fail(remote.clone(), outside(local));
|
||||
continue;
|
||||
}
|
||||
if let Some(parent) = local.parent()
|
||||
&& let Err(e) = tokio::fs::create_dir_all(parent).await
|
||||
{
|
||||
report.fail(remote.clone(), e.into());
|
||||
continue;
|
||||
}
|
||||
match fs.download(remote, local).await {
|
||||
Ok(()) => report.files += 1,
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
Ok(report)
|
||||
}
|
||||
|
||||
async fn remote_tree(
|
||||
fs: &RemoteFs,
|
||||
dir: &str,
|
||||
|
||||
@@ -631,11 +631,9 @@ fn spring_boot_apps(root: &Path, build: &Path, out: &mut Vec<RunConfig>) {
|
||||
}
|
||||
}
|
||||
|
||||
/// The module has main sources and Spring Boot on its classpath, as far as its build files
|
||||
/// tell: its own build, or a build above it in `build` that hands Spring Boot to its modules,
|
||||
/// references it (a dependency, the starter parent, the BOM or the plugin). A Maven module that
|
||||
/// depends on Spring Boot through a parent or another module is a Spring Boot application even
|
||||
/// without the packaging plugin; only `<pluginManagement>` alone doesn't count.
|
||||
/// The module has main sources, and its build applies the Spring Boot plugin: its own build
|
||||
/// file, or a build above it in `build` that applies it to its modules (a parent POM's
|
||||
/// `<build><plugins>`, Gradle's `subprojects` / `allprojects`).
|
||||
fn applies_spring_boot(build: &Path, module: &Path) -> bool {
|
||||
if !["java", "kotlin"].iter().any(|l| module.join("src/main").join(l).is_dir()) {
|
||||
return false;
|
||||
@@ -644,19 +642,15 @@ fn applies_spring_boot(build: &Path, module: &Path) -> bool {
|
||||
if pom.contains("<packaging>pom</packaging>") {
|
||||
return false;
|
||||
}
|
||||
if references_spring_boot(&without_plugin_management(&pom)) {
|
||||
if pom.contains("spring-boot-maven-plugin") {
|
||||
return true;
|
||||
}
|
||||
} else if GRADLE_BUILDS
|
||||
.iter()
|
||||
.filter_map(|n| read(&module.join(n)))
|
||||
.any(|text| applies_boot_gradle_plugin(&text) || text.contains("org.springframework.boot:"))
|
||||
{
|
||||
} else if GRADLE_BUILDS.iter().filter_map(|n| read(&module.join(n))).any(|text| applies_boot_gradle_plugin(&text)) {
|
||||
return true;
|
||||
}
|
||||
module.ancestors().skip(1).take_while(|dir| dir.starts_with(build)).any(|dir| {
|
||||
if let Some(pom) = read(&dir.join("pom.xml")) {
|
||||
return references_spring_boot(&without_plugin_management(&pom));
|
||||
return without_plugin_management(&pom).contains("spring-boot-maven-plugin");
|
||||
}
|
||||
GRADLE_BUILDS.iter().filter_map(|n| read(&dir.join(n))).any(|text| {
|
||||
(text.contains("subprojects") || text.contains("allprojects")) && applies_boot_gradle_plugin(&text)
|
||||
@@ -664,14 +658,6 @@ fn applies_spring_boot(build: &Path, module: &Path) -> bool {
|
||||
})
|
||||
}
|
||||
|
||||
/// A POM (without its `<pluginManagement>`) referencing Spring Boot: a dependency or the parent
|
||||
/// (`org.springframework.boot`), a starter, the BOM import or the plugin.
|
||||
fn references_spring_boot(pom: &str) -> bool {
|
||||
["org.springframework.boot", "spring-boot-starter", "spring-boot-dependencies", "spring-boot-maven-plugin"]
|
||||
.iter()
|
||||
.any(|m| pom.contains(m))
|
||||
}
|
||||
|
||||
/// A Gradle build applying the plugin (`id("org.springframework.boot")`, `apply plugin: '…'`),
|
||||
/// not only depending on Spring Boot (`org.springframework.boot:…`).
|
||||
fn applies_boot_gradle_plugin(text: &str) -> bool {
|
||||
|
||||
@@ -1112,12 +1112,8 @@ fn module_count(root: &Path) -> usize {
|
||||
/// named after its `artifactId` (usually its folder), a Gradle one `<project>.<path>.<source set>`.
|
||||
fn module_dir(root: &Path, name: &str) -> Option<String> {
|
||||
let folder = |dir: &Path| dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
|
||||
// A Maven module is named after its artifactId, so that match wins over a folder of the same
|
||||
// name anywhere above it (a checkout folder named like a child module's artifactId).
|
||||
if let Some(dir) = find_module(root, &|dir: &Path| pom_artifact(dir).is_some_and(|a| a == name)) {
|
||||
return Some(dir);
|
||||
}
|
||||
if let Some(dir) = find_module(root, &|dir: &Path| folder(dir) == name) {
|
||||
let exact = |dir: &Path| folder(dir) == name || pom_artifact(dir).is_some_and(|a| a == name);
|
||||
if let Some(dir) = find_module(root, &exact) {
|
||||
return Some(dir);
|
||||
}
|
||||
let gradle = name.strip_suffix(".main").or_else(|| name.strip_suffix(".test")).unwrap_or(name);
|
||||
|
||||
@@ -938,18 +938,7 @@ fn launch_env(root: &Path, config: &RunConfig) -> IdeResult<LaunchEnv> {
|
||||
vars.insert("PYTHONUNBUFFERED".into(), "1".into());
|
||||
}
|
||||
vars.extend(config.env.iter().map(|(k, v)| (k.clone(), v.clone())));
|
||||
let mut env = LaunchEnv { clear: !extras.include_system_env, vars };
|
||||
// `npm.cmd` is found on the login-shell and Windows user PATH, then started by its
|
||||
// full path. The script it runs (`node …`) only sees this process's PATH, which
|
||||
// does not include that directory, so `node` is not recognized.
|
||||
let cwd = resolve_cwd(root, config.cwd.as_deref());
|
||||
if !env.clear && !env.vars.keys().any(|k| k.eq_ignore_ascii_case("PATH")) {
|
||||
let path = crate::wrap::search_path_in(config, &cwd);
|
||||
if let Some(text) = path.to_str().filter(|s| !s.is_empty()) {
|
||||
env.vars.insert("PATH".into(), text.to_owned());
|
||||
}
|
||||
}
|
||||
Ok(env)
|
||||
Ok(LaunchEnv { clear: !extras.include_system_env, vars })
|
||||
}
|
||||
|
||||
/// What a run in the project at `root` inherits with "Include system environment variables"
|
||||
@@ -1457,42 +1446,6 @@ mod tests {
|
||||
assert_eq!(binary.program, script);
|
||||
}
|
||||
|
||||
fn bare_config(env: BTreeMap<String, String>) -> RunConfig {
|
||||
RunConfig {
|
||||
id: "c".into(),
|
||||
name: "c".into(),
|
||||
kind: "npm".into(),
|
||||
command: "npm".into(),
|
||||
args: vec!["run".into(), "start".into()],
|
||||
cwd: None,
|
||||
env,
|
||||
detected: true,
|
||||
is_test: false,
|
||||
debug_adapter: None,
|
||||
allow_parallel: false,
|
||||
extras: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_run_inherits_the_path_used_to_resolve_its_program() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let config = bare_config(BTreeMap::new());
|
||||
let env = launch_env(dir.path(), &config).unwrap();
|
||||
let path = env.vars.get("PATH").expect("child PATH");
|
||||
let search = crate::wrap::search_path_in(&config, dir.path());
|
||||
assert_eq!(path, search.to_str().unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_explicit_path_override_is_kept() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let config = bare_config(BTreeMap::from([("Path".into(), r"C:\tools".into())]));
|
||||
let env = launch_env(dir.path(), &config).unwrap();
|
||||
assert_eq!(env.vars.get("Path").map(String::as_str), Some(r"C:\tools"));
|
||||
assert_eq!(env.vars.keys().filter(|k| k.eq_ignore_ascii_case("PATH")).count(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shell_lines_use_cmd_verbatim_on_windows() {
|
||||
let line = r#"(if not exist "C:\T\openidea-run" mkdir "C:\T\openidea-run") && "C:\Program Files\rustc.exe" -o "C:\T\openidea-run\hi.exe" hi.rs"#;
|
||||
|
||||
@@ -380,57 +380,25 @@ fn a_root_build_disables_the_nested_scan() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn spring_boot_applications_need_spring_boot_and_a_main() {
|
||||
fn spring_boot_applications_need_the_plugin_and_a_main() {
|
||||
let main =
|
||||
"package demo;\n@SpringBootApplication\npublic class App {\n public static void main(String[] args) {}\n}\n";
|
||||
// A module without Spring Boot in its build, a configuration class without `main`, the
|
||||
// annotation in a comment, a parent POM.
|
||||
// A library using Spring Boot without the plugin, a configuration class without `main`,
|
||||
// the annotation in a comment, a parent POM.
|
||||
let dir = project(&[
|
||||
("plain/pom.xml", "<project><dependencies>commons-lang3</dependencies></project>"),
|
||||
("plain/src/main/java/demo/App.java", main),
|
||||
("lib/pom.xml", "<project><dependencies>spring-boot-starter</dependencies></project>"),
|
||||
("lib/src/main/java/demo/App.java", main),
|
||||
("svc/pom.xml", BOOT_POM),
|
||||
("svc/src/main/java/demo/Config.java", "package demo;\n@SpringBootApplication\npublic class Config {}\n"),
|
||||
(
|
||||
"svc/src/main/java/demo/Old.java",
|
||||
"package demo;\n// @SpringBootApplication\nclass Old { public static void main(String[] a) {} }\n",
|
||||
),
|
||||
("gr/build.gradle", "dependencies { implementation 'com.google.guava:guava:33.0.0-jre' }\n"),
|
||||
("gr/src/main/java/demo/App.java", main),
|
||||
]);
|
||||
let c = detect(dir.path());
|
||||
assert!(!c.iter().any(|c| c.kind == "spring-boot"), "{:?}", ids(&c));
|
||||
}
|
||||
|
||||
/// Spring Boot on the classpath is enough, as for IntelliJ IDEA: a module depending on a
|
||||
/// starter (directly or through its parent POM) without the packaging plugin, and Gradle's
|
||||
/// dependency on `org.springframework.boot:…`.
|
||||
#[test]
|
||||
fn spring_boot_applications_without_the_plugin() {
|
||||
let main =
|
||||
"package demo;\n@SpringBootApplication\npublic class App {\n public static void main(String[] args) {}\n}\n";
|
||||
let dir = project(&[
|
||||
(
|
||||
"lib/pom.xml",
|
||||
"<project><dependencies><dependency><groupId>org.springframework.boot</groupId>\
|
||||
<artifactId>spring-boot-starter-web</artifactId></dependency></dependencies></project>",
|
||||
),
|
||||
("lib/src/main/java/demo/App.java", main),
|
||||
("gr/build.gradle", "dependencies { implementation 'org.springframework.boot:spring-boot-starter' }\n"),
|
||||
("gr/src/main/java/demo/App.java", main),
|
||||
]);
|
||||
let c = detect(dir.path());
|
||||
assert_eq!(find(&c, "application:lib:demo.App").kind, "spring-boot");
|
||||
assert_eq!(find(&c, "application:gr:demo.App").kind, "spring-boot");
|
||||
|
||||
let parent = "<project><packaging>pom</packaging><modules><module>job</module></modules>\
|
||||
<parent><groupId>org.springframework.boot</groupId>\
|
||||
<artifactId>spring-boot-starter-parent</artifactId></parent></project>";
|
||||
let dir = project(&[
|
||||
("pom.xml", parent),
|
||||
("job/pom.xml", "<project><artifactId>job</artifactId></project>"),
|
||||
("job/src/main/java/demo/App.java", main),
|
||||
]);
|
||||
assert_eq!(find(&detect(dir.path()), "application:job:demo.App").kind, "spring-boot");
|
||||
assert!(!c.iter().any(|c| c.kind == "spring-boot"), "{:?}", ids(&c));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -860,38 +860,6 @@ fn java_applications_and_spring_boot_keep_their_module() {
|
||||
assert_eq!(reason(&r, "NoMain"), &SkipReason::NothingToRun);
|
||||
}
|
||||
|
||||
/// A checkout folder named like a child module's artifactId: IDEA's module is the child.
|
||||
#[test]
|
||||
fn maven_module_artifact_wins_over_a_folder_of_the_same_name() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(dir.path()).unwrap().join("demo-service");
|
||||
write(
|
||||
&root,
|
||||
"pom.xml",
|
||||
"<project><artifactId>demo-service-parent</artifactId><packaging>pom</packaging></project>",
|
||||
);
|
||||
write(
|
||||
&root,
|
||||
"app-web/pom.xml",
|
||||
"<project><parent><artifactId>demo-service-parent</artifactId></parent><artifactId>demo-service</artifactId></project>",
|
||||
);
|
||||
write(
|
||||
&root,
|
||||
".run/Demo.run.xml",
|
||||
&run_file(
|
||||
"Demo",
|
||||
r#"<configuration name="Demo" type="Application" factoryName="Application">
|
||||
<module name="demo-service" />
|
||||
<option name="MAIN_CLASS_NAME" value="com.example.Demo" />
|
||||
</configuration>"#,
|
||||
),
|
||||
);
|
||||
|
||||
let r = import_from(&root, &[]);
|
||||
|
||||
assert_eq!(get(&r, "Demo").extras.module.as_deref(), Some("app-web"));
|
||||
}
|
||||
|
||||
/// IDEA writes the working directory as a URL. On Windows `file://$PROJECT_DIR$`
|
||||
/// expands to `file://C:/project`, where the drive letter sits where the authority
|
||||
/// belongs; read as a path that is `C:project`, which resolves against the project
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -1,12 +1,13 @@
|
||||
//! Parallel walk + per-file search.
|
||||
|
||||
use crate::iter::for_each_match;
|
||||
use crate::line::line_matches;
|
||||
use crate::line::line_match;
|
||||
use crate::mask::FileMask;
|
||||
use crate::pattern::ScopePattern;
|
||||
use crate::query::{Compiled, line_terminator};
|
||||
use crate::{
|
||||
FileMatches, LineMatch, LiteralRange, Literals, PathFilter, SearchContext, SearchScope, SearchSummary, TextSource,
|
||||
FileMatches, LineMatch, LiteralKind, LiteralRange, Literals, PathFilter, SearchContext, SearchScope, SearchSummary,
|
||||
TextSource,
|
||||
};
|
||||
use grep_regex::RegexMatcher;
|
||||
use grep_searcher::{BinaryDetection, Searcher, SearcherBuilder, Sink, SinkMatch};
|
||||
@@ -51,7 +52,6 @@ struct Control<'a> {
|
||||
matches: AtomicU32,
|
||||
files: AtomicU32,
|
||||
max: u32,
|
||||
whole_word: bool,
|
||||
}
|
||||
|
||||
impl Control<'_> {
|
||||
@@ -131,7 +131,6 @@ pub(crate) fn run(req: Request<'_>) -> IdeResult<SearchSummary> {
|
||||
matches: AtomicU32::new(0),
|
||||
files: AtomicU32::new(0),
|
||||
max: if req.max_matches == 0 { DEFAULT_MAX_MATCHES } else { req.max_matches },
|
||||
whole_word: req.compiled.whole_word,
|
||||
},
|
||||
};
|
||||
let mut searcher_builder = SearcherBuilder::new();
|
||||
@@ -463,6 +462,12 @@ impl<'a> FileSink<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Kind of the comment or string literal containing byte `pos` (`literals` sorted).
|
||||
fn literal_at(literals: &[LiteralRange], pos: usize) -> Option<LiteralKind> {
|
||||
let i = literals.partition_point(|l| l.start <= pos);
|
||||
literals[..i].last().filter(|l| pos < l.end).map(|l| l.kind)
|
||||
}
|
||||
|
||||
impl Sink for FileSink<'_> {
|
||||
type Error = io::Error;
|
||||
|
||||
@@ -483,12 +488,12 @@ impl Sink for FileSink<'_> {
|
||||
let mut found = std::mem::take(&mut self.found);
|
||||
let mut ranges = std::mem::take(&mut self.ranges);
|
||||
found.clear();
|
||||
for_each_match(self.matcher, self.ctl.whole_word, &buffer[..range.end], range.start, |mm| {
|
||||
for_each_match(self.matcher, &buffer[..range.end], range.start, |mm| {
|
||||
found.push((mm.start() - range.start, mm.end() - range.start));
|
||||
});
|
||||
if let Some((context, literals)) = self.context {
|
||||
let block_start = usize::try_from(m.absolute_byte_offset()).unwrap_or(usize::MAX);
|
||||
found.retain(|&(a, _)| context.keeps(literals, block_start.saturating_add(a)));
|
||||
found.retain(|&(a, _)| context.accepts(literal_at(literals, block_start.saturating_add(a))));
|
||||
}
|
||||
|
||||
let mut next = found.iter().copied().peekable();
|
||||
@@ -516,7 +521,7 @@ impl Sink for FileSink<'_> {
|
||||
if !ranges.is_empty() {
|
||||
self.count = self.count.saturating_add(u32::try_from(ranges.len()).unwrap_or(u32::MAX));
|
||||
let line_no = u32::try_from(line_no).unwrap_or(u32::MAX);
|
||||
line_matches(line_no, &block[line_start..content_end], &ranges, &mut self.lines);
|
||||
self.lines.push(line_match(line_no, &block[line_start..content_end], &ranges));
|
||||
}
|
||||
line_start = line_end_incl;
|
||||
line_no += 1;
|
||||
@@ -701,7 +706,6 @@ mod budget_tests {
|
||||
matches: AtomicU32::new(0),
|
||||
files: AtomicU32::new(0),
|
||||
max,
|
||||
whole_word: false,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,27 +1,16 @@
|
||||
//! Match iteration that never splits a UTF-8 sequence after an empty match
|
||||
//! (`grep-matcher`'s iterators advance by a single byte), and that applies
|
||||
//! IDEA's whole-word rule.
|
||||
//! (`grep-matcher`'s iterators advance by a single byte).
|
||||
|
||||
use grep_matcher::{Captures, Match, Matcher};
|
||||
use grep_regex::{RegexCaptures, RegexMatcher};
|
||||
|
||||
/// Calls `f` for each non-overlapping match in `haystack[at..]`; `haystack[..at]`
|
||||
/// is only used as look-behind context. With `whole_word`, only [`is_whole_word`] matches.
|
||||
pub(crate) fn for_each_match(
|
||||
matcher: &RegexMatcher,
|
||||
whole_word: bool,
|
||||
haystack: &[u8],
|
||||
at: usize,
|
||||
mut f: impl FnMut(Match),
|
||||
) {
|
||||
/// is only used as look-behind context.
|
||||
pub(crate) fn for_each_match(matcher: &RegexMatcher, haystack: &[u8], at: usize, mut f: impl FnMut(Match)) {
|
||||
let mut at = at;
|
||||
let mut last_end = None;
|
||||
while at <= haystack.len() {
|
||||
let Ok(Some(m)) = matcher.find_at(haystack, at) else { break };
|
||||
if whole_word && !is_whole_word(haystack, m) {
|
||||
at = next_char(haystack, m.start());
|
||||
continue;
|
||||
}
|
||||
at = advance(haystack, m);
|
||||
if m.is_empty() && last_end == Some(m.end()) {
|
||||
continue;
|
||||
@@ -34,7 +23,6 @@ pub(crate) fn for_each_match(
|
||||
/// Like [`for_each_match`] but with capture groups.
|
||||
pub(crate) fn for_each_captures(
|
||||
matcher: &RegexMatcher,
|
||||
whole_word: bool,
|
||||
haystack: &[u8],
|
||||
caps: &mut RegexCaptures,
|
||||
mut f: impl FnMut(&RegexCaptures),
|
||||
@@ -46,10 +34,6 @@ pub(crate) fn for_each_captures(
|
||||
break;
|
||||
}
|
||||
let Some(m) = caps.get(0) else { break };
|
||||
if whole_word && !is_whole_word(haystack, m) {
|
||||
at = next_char(haystack, m.start());
|
||||
continue;
|
||||
}
|
||||
at = advance(haystack, m);
|
||||
if m.is_empty() && last_end == Some(m.end()) {
|
||||
continue;
|
||||
@@ -61,59 +45,12 @@ pub(crate) fn for_each_captures(
|
||||
|
||||
/// Where to resume after `m`: its end, or past the next char for empty matches.
|
||||
fn advance(haystack: &[u8], m: Match) -> usize {
|
||||
if !m.is_empty() { m.end() } else { next_char(haystack, m.end()) }
|
||||
}
|
||||
|
||||
/// The start of the char after the one at `at`.
|
||||
fn next_char(haystack: &[u8], at: usize) -> usize {
|
||||
let mut next = at + 1;
|
||||
if !m.is_empty() {
|
||||
return m.end();
|
||||
}
|
||||
let mut next = m.end() + 1;
|
||||
while next < haystack.len() && (haystack[next] & 0xC0) == 0x80 {
|
||||
next += 1;
|
||||
}
|
||||
next
|
||||
}
|
||||
|
||||
/// IDEA's whole word (`FindManagerBase.isWholeWord`): an edge where the match has an
|
||||
/// identifier character must not touch another one, unless it follows an escape such as
|
||||
/// `\n`; an edge with another character only must not repeat that character (`==` is not
|
||||
/// in `===`).
|
||||
fn is_whole_word(haystack: &[u8], m: Match) -> bool {
|
||||
let (start, end) = (m.start(), m.end());
|
||||
let word_start = match (char_before(haystack, start), char_at(haystack, start)) {
|
||||
(Some(prev), Some(first)) if is_identifier(first) => {
|
||||
let escaped = char_before(haystack, start - prev.len_utf8()) == Some('\\');
|
||||
!is_identifier(prev) || escaped
|
||||
}
|
||||
(Some(prev), Some(first)) => prev != first,
|
||||
_ => true,
|
||||
};
|
||||
let word_end = match (char_at(haystack, end), char_before(haystack, end)) {
|
||||
(Some(next), Some(last)) if is_identifier(last) => !is_identifier(next),
|
||||
(Some(next), Some(last)) => next != last,
|
||||
(Some(_), None) | (None, _) => true,
|
||||
};
|
||||
word_start && word_end
|
||||
}
|
||||
|
||||
/// Java's identifier part, near enough: letters, digits, `_` and `$`.
|
||||
fn is_identifier(c: char) -> bool {
|
||||
c.is_alphanumeric() || c == '_' || c == '$'
|
||||
}
|
||||
|
||||
/// The char starting at byte `at` (`None` at the end or in invalid UTF-8).
|
||||
fn char_at(haystack: &[u8], at: usize) -> Option<char> {
|
||||
let rest = haystack.get(at..)?;
|
||||
let len = rest.len().min(4);
|
||||
let s = match std::str::from_utf8(&rest[..len]) {
|
||||
Ok(s) => s,
|
||||
Err(e) => std::str::from_utf8(&rest[..e.valid_up_to()]).ok()?,
|
||||
};
|
||||
s.chars().next()
|
||||
}
|
||||
|
||||
/// The char ending at byte `at` (`None` at the start or in invalid UTF-8).
|
||||
fn char_before(haystack: &[u8], at: usize) -> Option<char> {
|
||||
let head = haystack.get(..at)?;
|
||||
let from = head.len().saturating_sub(4);
|
||||
(from..head.len()).find_map(|i| std::str::from_utf8(&head[i..]).ok().and_then(|s| s.chars().next_back()))
|
||||
}
|
||||
@@ -22,7 +22,7 @@ pub use mask::FileMask;
|
||||
pub use pattern::ScopePattern;
|
||||
pub use replace::{
|
||||
ReplaceEvent, ReplaceHost, ReplacePreview, ReplaceSummary, ReplaceTarget, apply_edits, preserve_case, preview,
|
||||
replace_files, replace_files_in_context, replacement_edits,
|
||||
replace_files, replacement_edits,
|
||||
};
|
||||
pub use words::{WordFiles, WordQuery, files_with_word};
|
||||
|
||||
@@ -99,15 +99,8 @@ impl SearchContext {
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether a match starting at byte `at` is kept, given the file's sorted comments and
|
||||
/// string literals. Find and Replace both filter with it, so they keep the same matches.
|
||||
pub fn keeps(self, literals: &[LiteralRange], at: usize) -> bool {
|
||||
let i = literals.partition_point(|l| l.start <= at);
|
||||
self.accepts(literals[..i].last().filter(|l| at < l.end).map(|l| l.kind))
|
||||
}
|
||||
|
||||
/// Only matches inside comments / string literals: files without any are skipped.
|
||||
pub(crate) fn needs_literals(self) -> bool {
|
||||
fn needs_literals(self) -> bool {
|
||||
matches!(self, Self::InComments | Self::InStringLiterals)
|
||||
}
|
||||
}
|
||||
@@ -167,8 +160,7 @@ pub type PathFilter<'a> = &'a (dyn Fn(&str) -> bool + Sync);
|
||||
pub struct LineMatch {
|
||||
/// 0-based line.
|
||||
pub line: u32,
|
||||
/// Line text, truncated around the matches for very long lines: such a line comes as one
|
||||
/// `LineMatch` per window, so the same `line` can repeat.
|
||||
/// Line text, truncated around the match for very long lines.
|
||||
pub text: String,
|
||||
/// UTF-16 column ranges within `text`.
|
||||
pub ranges: Vec<(u32, u32)>,
|
||||
@@ -293,9 +285,7 @@ pub fn match_ranges(text: &str, query: &SearchQuery) -> IdeResult<Vec<(usize, us
|
||||
}
|
||||
let compiled = query::compile(query)?;
|
||||
let mut out = Vec::new();
|
||||
iter::for_each_match(&compiled.matcher, compiled.whole_word, text.as_bytes(), 0, |m| {
|
||||
out.push((m.start(), m.end()))
|
||||
});
|
||||
iter::for_each_match(&compiled.matcher, text.as_bytes(), 0, |m| out.push((m.start(), m.end())));
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
@@ -318,7 +308,7 @@ pub fn replace_in_text(text: &str, query: &SearchQuery, replacement: &str) -> Id
|
||||
let mut out = Vec::with_capacity(text.len());
|
||||
let mut count = 0u32;
|
||||
let mut last = 0;
|
||||
iter::for_each_captures(matcher, compiled.whole_word, haystack, &mut caps, |caps| {
|
||||
iter::for_each_captures(matcher, haystack, &mut caps, |caps| {
|
||||
let Some(m) = caps.get(0) else { return };
|
||||
out.extend_from_slice(&haystack[last..m.start()]);
|
||||
last = m.end();
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
//! Turns a matched line plus byte ranges into [`LineMatch`]es with UTF-16
|
||||
//! columns. A very long line is cut into windows: one around its first match
|
||||
//! and the matches that fit with it, then one around each match left out.
|
||||
//! Turns a matched line plus byte ranges into a [`LineMatch`] with UTF-16
|
||||
//! columns, truncating very long lines to a window around the first match.
|
||||
|
||||
use crate::LineMatch;
|
||||
|
||||
@@ -9,57 +8,33 @@ pub(crate) const MAX_LINE_LEN: usize = 500;
|
||||
/// How much text before the first match a truncated line keeps.
|
||||
const CONTEXT_BEFORE: usize = 100;
|
||||
|
||||
/// Appends the matches of one line to `out`: a single [`LineMatch`], or one per window of a
|
||||
/// very long line. `line` excludes the line terminator; `ranges` are sorted, non-overlapping
|
||||
/// `line` excludes the line terminator; `ranges` are sorted, non-overlapping
|
||||
/// byte ranges within `line`.
|
||||
pub(crate) fn line_matches(line_no: u32, line: &[u8], ranges: &[(usize, usize)], out: &mut Vec<LineMatch>) {
|
||||
pub(crate) fn line_match(line_no: u32, line: &[u8], ranges: &[(usize, usize)]) -> LineMatch {
|
||||
match std::str::from_utf8(line) {
|
||||
Ok(s) => from_str(line_no, s, ranges, out),
|
||||
Ok(s) => from_str(line_no, s, ranges),
|
||||
Err(_) => {
|
||||
let (s, mapped) = lossy(line, ranges);
|
||||
from_str(line_no, &s, &mapped, out)
|
||||
from_str(line_no, &s, &mapped)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
fn line_match(line_no: u32, line: &[u8], ranges: &[(usize, usize)]) -> LineMatch {
|
||||
let mut out = Vec::new();
|
||||
line_matches(line_no, line, ranges, &mut out);
|
||||
out.swap_remove(0)
|
||||
}
|
||||
|
||||
fn from_str(line_no: u32, s: &str, ranges: &[(usize, usize)], out: &mut Vec<LineMatch>) {
|
||||
if s.len() <= MAX_LINE_LEN || utf16_len(s.as_bytes()) <= MAX_LINE_LEN {
|
||||
out.push(in_window(line_no, s, ranges, (0, s.len())).0);
|
||||
return;
|
||||
}
|
||||
let mut rest = ranges;
|
||||
loop {
|
||||
let bounds = window(s, floor_boundary(s, rest.first().map_or(0, |r| r.0.min(s.len()))));
|
||||
let (m, used) = in_window(line_no, s, rest, bounds);
|
||||
out.push(m);
|
||||
rest = &rest[used.max(1)..];
|
||||
if rest.is_empty() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The [`LineMatch`] of the text in `bounds` with the leading `ranges` that end inside it (at
|
||||
/// least the first one, cut to the window), and how many ranges it took.
|
||||
fn in_window(line_no: u32, s: &str, ranges: &[(usize, usize)], (start, end): (usize, usize)) -> (LineMatch, usize) {
|
||||
fn from_str(line_no: u32, s: &str, ranges: &[(usize, usize)]) -> LineMatch {
|
||||
let (start, end) = if s.len() <= MAX_LINE_LEN || utf16_len(s.as_bytes()) <= MAX_LINE_LEN {
|
||||
(0, s.len())
|
||||
} else {
|
||||
window(s, floor_boundary(s, ranges.first().map_or(0, |r| r.0.min(s.len()))))
|
||||
};
|
||||
let text = &s[start..end];
|
||||
let text_offset = if start == 0 { 0 } else { utf16_len(&s.as_bytes()[..start]) };
|
||||
|
||||
let mut out = Vec::with_capacity(ranges.len());
|
||||
let (mut pos, mut col) = (start, 0usize);
|
||||
let mut used = 0;
|
||||
for &(a, b) in ranges {
|
||||
if a > end || (a == end && b > a) || (used > 0 && b > end) {
|
||||
if a > end || (a == end && b > a) {
|
||||
break;
|
||||
}
|
||||
used += 1;
|
||||
let (a, b) = (floor_boundary(s, a.max(start)), ceil_boundary(s, b.min(end)));
|
||||
if a < pos {
|
||||
continue;
|
||||
@@ -70,7 +45,7 @@ fn in_window(line_no: u32, s: &str, ranges: &[(usize, usize)], (start, end): (us
|
||||
pos = b;
|
||||
out.push((col_a as u32, col as u32));
|
||||
}
|
||||
(LineMatch { line: line_no, text: text.to_owned(), ranges: out, text_offset: text_offset as u32 }, used)
|
||||
LineMatch { line: line_no, text: text.to_owned(), ranges: out, text_offset: text_offset as u32 }
|
||||
}
|
||||
|
||||
/// Byte window `[start, end)` of at most `MAX_LINE_LEN` UTF-16 units that
|
||||
@@ -211,30 +186,4 @@ mod tests {
|
||||
assert_eq!(m.ranges, vec![(100, 106)]);
|
||||
assert!(utf16_len(m.text.as_bytes()) <= MAX_LINE_LEN);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn matches_outside_the_first_window_get_their_own() {
|
||||
// Two matches 100 apart share a window; the one 1000 further gets another.
|
||||
let s = format!("{}ab{}cd{}ef{}", "x".repeat(1000), "x".repeat(100), "x".repeat(1000), "x".repeat(10));
|
||||
let at = |needle: &str| s.find(needle).unwrap();
|
||||
let ranges = [(at("ab"), at("ab") + 2), (at("cd"), at("cd") + 2), (at("ef"), at("ef") + 2)];
|
||||
let mut out = Vec::new();
|
||||
line_matches(7, s.as_bytes(), &ranges, &mut out);
|
||||
let found: Vec<Vec<u32>> =
|
||||
out.iter().map(|m| m.ranges.iter().map(|&(a, _)| m.text_offset + a).collect()).collect();
|
||||
let col = |needle: &str| at(needle) as u32;
|
||||
assert_eq!(found, vec![vec![col("ab"), col("cd")], vec![col("ef")]]);
|
||||
assert!(out.iter().all(|m| m.line == 7 && utf16_len(m.text.as_bytes()) <= MAX_LINE_LEN));
|
||||
assert_eq!(&out[1].text[out[1].ranges[0].0 as usize..out[1].ranges[0].1 as usize], "ef");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_match_longer_than_the_window_is_cut_to_it() {
|
||||
let s = format!("{}{}tail", "x".repeat(100), "y".repeat(1000));
|
||||
let mut out = Vec::new();
|
||||
line_matches(0, s.as_bytes(), &[(100, 1100), (1100, 1104)], &mut out);
|
||||
assert_eq!(out.len(), 2);
|
||||
assert_eq!(out[0].ranges, vec![(100, 500)]);
|
||||
assert_eq!(out[1].text_offset + out[1].ranges[0].0, 1100);
|
||||
}
|
||||
}
|
||||
@@ -9,8 +9,6 @@ use ide_core::{IdeError, IdeResult};
|
||||
pub(crate) struct Compiled {
|
||||
pub matcher: RegexMatcher,
|
||||
pub multi_line: bool,
|
||||
/// Keep only whole-word matches ([`crate::iter`] checks IDEA's rule on each match).
|
||||
pub whole_word: bool,
|
||||
}
|
||||
|
||||
/// The line terminator shared by the matcher and the searcher. CRLF mode lets
|
||||
@@ -21,13 +19,12 @@ pub(crate) fn line_terminator() -> LineTerminator {
|
||||
|
||||
pub(crate) fn compile(query: &SearchQuery) -> IdeResult<Compiled> {
|
||||
let multi_line = needs_multi_line(query);
|
||||
let whole_word = query.whole_word;
|
||||
match build(query, multi_line) {
|
||||
Ok(matcher) => Ok(Compiled { matcher, multi_line, whole_word }),
|
||||
Ok(matcher) => Ok(Compiled { matcher, multi_line }),
|
||||
// Patterns such as `[\n]` or `\x0A` can only match across lines;
|
||||
// retry in multi-line mode before reporting an error.
|
||||
Err(err) if !multi_line => match build(query, true) {
|
||||
Ok(matcher) => Ok(Compiled { matcher, multi_line: true, whole_word }),
|
||||
Ok(matcher) => Ok(Compiled { matcher, multi_line: true }),
|
||||
Err(_) => Err(invalid_pattern(query, &err)),
|
||||
},
|
||||
Err(err) => Err(invalid_pattern(query, &err)),
|
||||
@@ -38,8 +35,7 @@ fn build(query: &SearchQuery, multi_line: bool) -> Result<RegexMatcher, grep_reg
|
||||
let mut b = RegexMatcherBuilder::new();
|
||||
b.case_smart(false)
|
||||
.case_insensitive(!query.case_sensitive)
|
||||
// Not `.word()`: ripgrep's rule wants a non-word character on both sides even of
|
||||
// `foo(`, IDEA's (in `iter`) only beside the match's identifier characters.
|
||||
.word(query.whole_word)
|
||||
.fixed_strings(!query.is_regex)
|
||||
.unicode(true)
|
||||
// `^`/`$` always mean start/end of line, as in IDEA and ripgrep.
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
//! (the document layer in the app, so open editors update and each file is one
|
||||
//! undoable step).
|
||||
|
||||
use crate::{LiteralRange, Literals, SearchContext, SearchQuery, iter, query};
|
||||
use crate::{SearchQuery, iter, query};
|
||||
use grep_matcher::{Captures, Matcher};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, Pos, Range, TextEdit};
|
||||
use serde::{Deserialize, Serialize};
|
||||
@@ -128,11 +128,10 @@ pub fn replacement_edits(
|
||||
preserve: bool,
|
||||
only: Option<&[Pos]>,
|
||||
) -> IdeResult<Vec<TextEdit>> {
|
||||
edits_except(text, query, replacement, preserve, only, None, None)
|
||||
edits_except(text, query, replacement, preserve, only, None)
|
||||
}
|
||||
|
||||
/// [`replacement_edits`] leaving out the matches that start at `skip` and, given the text's
|
||||
/// comments and string literals, those outside the query's [`crate::SearchContext`].
|
||||
/// [`replacement_edits`] leaving out the matches that start at `skip`.
|
||||
fn edits_except(
|
||||
text: &str,
|
||||
query: &SearchQuery,
|
||||
@@ -140,7 +139,6 @@ fn edits_except(
|
||||
preserve: bool,
|
||||
only: Option<&[Pos]>,
|
||||
skip: Option<&[Pos]>,
|
||||
literals: Option<&[LiteralRange]>,
|
||||
) -> IdeResult<Vec<TextEdit>> {
|
||||
if query.pattern.is_empty() {
|
||||
return Ok(Vec::new());
|
||||
@@ -155,13 +153,10 @@ fn edits_except(
|
||||
let mut caps = matcher.new_captures().map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
let mut edits = Vec::new();
|
||||
let mut buf = Vec::new();
|
||||
iter::for_each_captures(matcher, compiled.whole_word, haystack, &mut caps, |caps| {
|
||||
iter::for_each_captures(matcher, haystack, &mut caps, |caps| {
|
||||
let Some(m) = caps.get(0) else { return };
|
||||
let start = lines.pos(m.start());
|
||||
if only.as_ref().is_some_and(|o| !o.contains(&start))
|
||||
|| skip.contains(&start)
|
||||
|| literals.is_some_and(|l| !query.context.keeps(l, m.start()))
|
||||
{
|
||||
if only.as_ref().is_some_and(|o| !o.contains(&start)) || skip.contains(&start) {
|
||||
return;
|
||||
}
|
||||
let mut new_text = if query.is_regex {
|
||||
@@ -232,23 +227,6 @@ pub fn replace_files(
|
||||
cancel: &CancellationToken,
|
||||
on_event: &dyn Fn(ReplaceEvent),
|
||||
) -> IdeResult<ReplaceSummary> {
|
||||
replace_files_in_context(host, query, replacement, preserve, targets, None, cancel, on_event)
|
||||
}
|
||||
|
||||
/// [`replace_files`] honouring [`SearchQuery::context`] with the comments and string literals
|
||||
/// `literals` finds, as [`crate::search_in_context`] does; without it every match is plain code.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn replace_files_in_context(
|
||||
host: &dyn ReplaceHost,
|
||||
query: &SearchQuery,
|
||||
replacement: &str,
|
||||
preserve: bool,
|
||||
targets: &[ReplaceTarget],
|
||||
literals: Option<Literals<'_>>,
|
||||
cancel: &CancellationToken,
|
||||
on_event: &dyn Fn(ReplaceEvent),
|
||||
) -> IdeResult<ReplaceSummary> {
|
||||
let literals = literals.filter(|_| query.context != SearchContext::Any);
|
||||
// Fail fast on an invalid pattern instead of once per file.
|
||||
if !query.pattern.is_empty() {
|
||||
query::compile(query)?;
|
||||
@@ -266,14 +244,8 @@ pub fn replace_files_in_context(
|
||||
if only.is_some_and(|o| o.is_empty()) {
|
||||
continue;
|
||||
}
|
||||
let result = host.edit_file(&target.path, &mut |text| {
|
||||
let found = match literals.map(|l| l(&target.path, text)) {
|
||||
// No syntax tree: nothing is in a comment or string, as in the search.
|
||||
Some(None) if query.context.needs_literals() => return Ok(Vec::new()),
|
||||
found => found.map(Option::unwrap_or_default),
|
||||
};
|
||||
edits_except(text, query, replacement, preserve, only, skip, found.as_deref())
|
||||
});
|
||||
let result =
|
||||
host.edit_file(&target.path, &mut |text| edits_except(text, query, replacement, preserve, only, skip));
|
||||
match result {
|
||||
Ok(n) => {
|
||||
if n > 0 {
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, Pos, TextEdit};
|
||||
use ide_search::{
|
||||
LiteralKind, LiteralRange, ReplaceEvent, ReplaceHost, ReplaceTarget, SearchQuery, SearchScope, preserve_case,
|
||||
preview, replace_files, replace_files_in_context, replacement_edits,
|
||||
ReplaceEvent, ReplaceHost, ReplaceTarget, SearchQuery, SearchScope, preserve_case, preview, replace_files,
|
||||
replacement_edits,
|
||||
};
|
||||
use std::collections::HashMap;
|
||||
use std::path::{Path, PathBuf};
|
||||
@@ -169,46 +169,3 @@ fn replace_files_respects_selected_matches_and_invalid_patterns() {
|
||||
let err = replace_files(&docs, ®ex("("), "x", false, &t, &CancellationToken::new(), &|_| {}).unwrap_err();
|
||||
assert_eq!(err.kind, ide_core::error::ErrorKind::InvalidInput);
|
||||
}
|
||||
|
||||
/// `// …` comments and `"…"` strings of `.rs` files; other files have no syntax tree.
|
||||
fn toy_literals(path: &Path, text: &str) -> Option<Vec<LiteralRange>> {
|
||||
if path.extension().is_none_or(|e| e != "rs") {
|
||||
return None;
|
||||
}
|
||||
let mut out = Vec::new();
|
||||
for (i, _) in text.match_indices("//") {
|
||||
let end = text[i..].find('\n').map_or(text.len(), |n| i + n);
|
||||
out.push(LiteralRange { start: i, end, kind: LiteralKind::Comment });
|
||||
}
|
||||
let quotes: Vec<usize> = text.match_indices('"').map(|(i, _)| i).collect();
|
||||
for pair in quotes.chunks(2) {
|
||||
if let [a, b] = pair {
|
||||
out.push(LiteralRange { start: *a, end: b + 1, kind: LiteralKind::String });
|
||||
}
|
||||
}
|
||||
out.sort_by_key(|l| l.start);
|
||||
Some(out)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn replace_files_in_context_keeps_to_the_search_context() {
|
||||
use ide_search::SearchContext as C;
|
||||
let text = "foo(\"foo\"); // foo\nfoo\n";
|
||||
let plain = "foo // foo\n";
|
||||
let cases = [
|
||||
(C::Any, "x(\"x\"); // x\nx\n", "x // x\n"),
|
||||
(C::InComments, "foo(\"foo\"); // x\nfoo\n", plain),
|
||||
(C::InStringLiterals, "foo(\"x\"); // foo\nfoo\n", plain),
|
||||
(C::ExceptComments, "x(\"x\"); // foo\nx\n", "x // x\n"),
|
||||
(C::ExceptStringLiterals, "x(\"foo\"); // x\nx\n", "x // x\n"),
|
||||
(C::ExceptCommentsAndStringLiterals, "x(\"foo\"); // foo\nx\n", "x // x\n"),
|
||||
];
|
||||
for (context, in_rs, in_txt) in cases {
|
||||
let docs = FakeDocs::with(&[("a.rs", text), ("b.txt", plain)]);
|
||||
let q = SearchQuery { context, ..query("foo") };
|
||||
let t = targets(&["a.rs", "b.txt"]);
|
||||
replace_files_in_context(&docs, &q, "x", false, &t, Some(&toy_literals), &CancellationToken::new(), &|_| {})
|
||||
.unwrap();
|
||||
assert_eq!((docs.text("a.rs").as_str(), docs.text("b.txt").as_str()), (in_rs, in_txt), "{context:?}");
|
||||
}
|
||||
}
|
||||
@@ -132,36 +132,6 @@ fn whole_word() {
|
||||
assert_eq!(views[0].matches[0].ranges, vec![(0, 3), (27, 30), (32, 35)]);
|
||||
}
|
||||
|
||||
/// IDEA's whole word: a word boundary is needed only at an edge where the match has an
|
||||
/// identifier character; a punctuation edge only needs a different character beside it.
|
||||
#[test]
|
||||
fn whole_word_needs_a_boundary_only_at_identifier_edges() {
|
||||
let starts = |text: &str, q: SearchQuery| -> Vec<usize> {
|
||||
let q = SearchQuery { whole_word: true, ..q };
|
||||
ide_search::match_ranges(text, &q).unwrap().into_iter().map(|r| r.0).collect()
|
||||
};
|
||||
let text = "doWork(arg); redoWork(x); list: string[] = [];";
|
||||
assert_eq!(starts(text, query("doWork(")), [0]);
|
||||
assert_eq!(starts(text, query("(arg)")), [6]);
|
||||
assert_eq!(starts(text, query("[]")), [38, 43]);
|
||||
assert_eq!(starts(text, query("list")), [26]);
|
||||
assert_eq!(starts("a == b; c === d", query("==")), [2]);
|
||||
// `$` is part of an identifier (Java, Kotlin, JavaScript).
|
||||
assert_eq!(starts("foo$bar foo", query("foo")), [8]);
|
||||
// After an escape such as `\n`, a word starts.
|
||||
assert_eq!(starts(r#"s = "\nfoo";"#, query("foo")), [7]);
|
||||
assert_eq!(starts("é1 1 éé", query("1")), [4]);
|
||||
// Regex matches follow the same rule.
|
||||
assert_eq!(starts(text, regex(r"\w+\(")), [0, 13]);
|
||||
assert_eq!(starts(text, regex(r"\[\]")), [38, 43]);
|
||||
|
||||
let p = project(&[("a.ts", text.as_bytes())]);
|
||||
let (views, summary) = run(p.path(), &SearchQuery { whole_word: true, ..query("[]") });
|
||||
assert_eq!((summary.matches, views[0].matches[0].ranges.clone()), (2, vec![(38, 40), (43, 45)]));
|
||||
let (out, n) = replace_in_text(text, &SearchQuery { whole_word: true, ..query("doWork(") }, "run(").unwrap();
|
||||
assert_eq!((out.as_str(), n), ("run(arg); redoWork(x); list: string[] = [];", 1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_regex_is_reported() {
|
||||
let p = project(&[("a.txt", b"x\n")]);
|
||||
@@ -461,41 +431,6 @@ fn long_lines_are_truncated() {
|
||||
assert_eq!(second.text, "short needle");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_match_of_a_long_line_is_reported_in_its_own_window() {
|
||||
let long = format!("a='needle';{}b='needle';{}needle!\n", "x".repeat(2000), "y".repeat(2000));
|
||||
let p = project(&[("min.js", long.as_bytes())]);
|
||||
let (views, summary) = run(p.path(), &query("needle"));
|
||||
assert_eq!(summary.matches, 3);
|
||||
let lines = &views[0].matches;
|
||||
assert_eq!(lines.len(), 3, "one window per far-apart match");
|
||||
let line_utf16: Vec<u16> = long.trim_end().encode_utf16().collect();
|
||||
let mut starts = Vec::new();
|
||||
for m in lines {
|
||||
assert_eq!(m.line, 0);
|
||||
assert!(m.text.encode_utf16().count() <= 500);
|
||||
let [(a, b)] = m.ranges[..] else { panic!("{:?}", m.ranges) };
|
||||
let text: Vec<u16> = m.text.encode_utf16().collect();
|
||||
assert_eq!(String::from_utf16(&text[a as usize..b as usize]).unwrap(), "needle");
|
||||
let col = (m.text_offset + a) as usize;
|
||||
assert_eq!(String::from_utf16(&line_utf16[col..col + 6]).unwrap(), "needle");
|
||||
starts.push(ide_core::Pos::new(0, m.text_offset + a));
|
||||
}
|
||||
// The reported positions are the ones Replace takes: all of them are replaced.
|
||||
let edits = ide_search::replacement_edits(&long, &query("needle"), "pin", false, Some(&starts)).unwrap();
|
||||
assert_eq!(edits.len(), 3);
|
||||
assert!(!ide_search::apply_edits(&long, &edits).contains("needle"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn match_limit_counts_every_match_of_a_long_line() {
|
||||
let long = format!("needle{}needle{}needle\n", "x".repeat(1000), "y".repeat(1000));
|
||||
let p = project(&[("min.js", long.as_bytes())]);
|
||||
let (views, summary) = run(p.path(), &SearchQuery { max_matches: 2, ..query("needle") });
|
||||
assert!(summary.limit_hit);
|
||||
assert_eq!((summary.matches, total(&views)), (2, 2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn multi_line_matches() {
|
||||
let p = project(&[("a.rs", b"fn foo() {\n bar();\n}\nfoo\nbar\n")]);
|
||||
|
||||
@@ -197,62 +197,28 @@ fn software_term(lower: &str) -> bool {
|
||||
.is_some_and(|w| ["s", "x", "z", "ch", "sh"].iter().any(|e| w.ends_with(e)) && plural_of(w))
|
||||
}
|
||||
|
||||
/// A custom dictionary: a word list, or a Hunspell dictionary with its affix rules.
|
||||
enum CustomDictionary {
|
||||
Words(HashSet<String>),
|
||||
Hunspell(Box<spellbook::Dictionary>),
|
||||
}
|
||||
|
||||
impl CustomDictionary {
|
||||
/// Whether the lowercased `lower` is a word of it, in any case style.
|
||||
fn contains(&self, lower: &str) -> bool {
|
||||
match self {
|
||||
Self::Words(words) => words.contains(lower),
|
||||
Self::Hunspell(dict) => {
|
||||
dict.check(lower) || dict.check(&capitalize(lower)) || dict.check(&lower.to_uppercase())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The `.aff` next to a Hunspell `.dic` (`de_DE.dic` → `de_DE.aff`), if there is one.
|
||||
fn affix_file(path: &Path) -> Option<PathBuf> {
|
||||
if !path.extension().is_some_and(|e| e.eq_ignore_ascii_case("dic")) {
|
||||
return None;
|
||||
}
|
||||
["aff", "AFF"].into_iter().map(|ext| path.with_extension(ext)).find(|aff| aff.is_file())
|
||||
}
|
||||
|
||||
/// A custom dictionary file: a Hunspell `.dic` with the `.aff` beside it, with
|
||||
/// its affix, compounding and case rules; otherwise a plain word list (a `.dic`
|
||||
/// alone: leading count line and `/FLAGS` ignored). Cached by modification time.
|
||||
fn dictionary_file(path: &Path) -> Arc<CustomDictionary> {
|
||||
type Stamp = (Option<SystemTime>, Option<SystemTime>);
|
||||
type Cache = HashMap<PathBuf, (Stamp, Arc<CustomDictionary>)>;
|
||||
/// Words of a custom dictionary file: a plain word list or a Hunspell `.dic`
|
||||
/// (leading count line and `/FLAGS` ignored). Cached by modification time.
|
||||
fn dictionary_file(path: &Path) -> Arc<HashSet<String>> {
|
||||
type Cache = HashMap<PathBuf, (Option<SystemTime>, Arc<HashSet<String>>)>;
|
||||
static CACHE: OnceLock<Mutex<Cache>> = OnceLock::new();
|
||||
let modified = |p: &Path| std::fs::metadata(p).and_then(|m| m.modified()).ok();
|
||||
let aff = affix_file(path);
|
||||
let stamp = (modified(path), aff.as_deref().and_then(modified));
|
||||
if let Some((at, dict)) = CACHE.get_or_init(Default::default).lock().get(path)
|
||||
&& *at == stamp
|
||||
let modified = std::fs::metadata(path).and_then(|m| m.modified()).ok();
|
||||
let mut cache = CACHE.get_or_init(Default::default).lock();
|
||||
if let Some((at, words)) = cache.get(path)
|
||||
&& *at == modified
|
||||
{
|
||||
return dict.clone();
|
||||
return words.clone();
|
||||
}
|
||||
let read = |p: &Path| {
|
||||
std::fs::read_to_string(p).map_err(|e| tracing::debug!("custom dictionary {}: {e}", p.display())).ok()
|
||||
let words: HashSet<String> = match std::fs::read_to_string(path) {
|
||||
Ok(text) => parse_word_list(&text),
|
||||
Err(e) => {
|
||||
tracing::debug!("custom dictionary {}: {e}", path.display());
|
||||
HashSet::new()
|
||||
}
|
||||
};
|
||||
let text = read(path).unwrap_or_default();
|
||||
let hunspell = aff.as_deref().and_then(read).and_then(|aff| {
|
||||
spellbook::Dictionary::new(&aff, &text)
|
||||
.map_err(|e| tracing::warn!("Hunspell dictionary {}: {e}", path.display()))
|
||||
.ok()
|
||||
});
|
||||
let dict = Arc::new(match hunspell {
|
||||
Some(dict) => CustomDictionary::Hunspell(Box::new(dict)),
|
||||
None => CustomDictionary::Words(parse_word_list(&text)),
|
||||
});
|
||||
CACHE.get_or_init(Default::default).lock().insert(path.to_path_buf(), (stamp, dict.clone()));
|
||||
dict
|
||||
let words = Arc::new(words);
|
||||
cache.insert(path.to_path_buf(), (modified, words.clone()));
|
||||
words
|
||||
}
|
||||
|
||||
/// Lowercased words of a word list / Hunspell `.dic` text.
|
||||
@@ -272,7 +238,7 @@ pub fn parse_word_list(text: &str) -> HashSet<String> {
|
||||
#[derive(Default)]
|
||||
pub struct Speller {
|
||||
accepted: HashSet<String>,
|
||||
custom: Vec<Arc<CustomDictionary>>,
|
||||
custom: Vec<Arc<HashSet<String>>>,
|
||||
}
|
||||
|
||||
impl Speller {
|
||||
@@ -385,31 +351,16 @@ impl Speller {
|
||||
&& !near_word(lower, |w| english().check(w))
|
||||
}
|
||||
|
||||
/// Replacements for `word`, best first, in the word's case style: from the
|
||||
/// English dictionary and the custom Hunspell dictionaries, the closest first.
|
||||
/// Replacements for `word`, best first, in the word's case style.
|
||||
pub fn suggest(&self, word: &str, limit: usize) -> Vec<String> {
|
||||
let hunspell = self.custom.iter().filter_map(|d| match d.as_ref() {
|
||||
CustomDictionary::Hunspell(dict) => Some(dict.as_ref()),
|
||||
CustomDictionary::Words(_) => None,
|
||||
});
|
||||
let dicts: Vec<&spellbook::Dictionary> = std::iter::once(english()).chain(hunspell).collect();
|
||||
let mut out = Vec::new();
|
||||
for dict in &dicts {
|
||||
let mut found = Vec::new();
|
||||
dict.suggest(word, &mut found);
|
||||
if found.is_empty() && word.chars().next().is_some_and(char::is_uppercase) {
|
||||
dict.suggest(&word.to_lowercase(), &mut found);
|
||||
found = found.into_iter().map(|s| capitalize(&s)).collect();
|
||||
}
|
||||
out.extend(found);
|
||||
english().suggest(word, &mut out);
|
||||
if out.is_empty() && word.chars().next().is_some_and(char::is_uppercase) {
|
||||
english().suggest(&word.to_lowercase(), &mut out);
|
||||
out = out.into_iter().map(|s| capitalize(&s)).collect();
|
||||
}
|
||||
let mut seen = HashSet::new();
|
||||
out.retain(|s| s != word && seen.insert(s.clone()));
|
||||
if dicts.len() > 1 {
|
||||
// Stable: within a distance each dictionary keeps its own order, English first.
|
||||
let lower = word.to_lowercase();
|
||||
out.sort_by_key(|s| edit_distance(&lower, &s.to_lowercase()));
|
||||
}
|
||||
out.truncate(limit);
|
||||
out
|
||||
}
|
||||
@@ -465,22 +416,6 @@ impl Speller {
|
||||
}
|
||||
}
|
||||
|
||||
/// Levenshtein distance in characters.
|
||||
fn edit_distance(a: &str, b: &str) -> usize {
|
||||
let b: Vec<char> = b.chars().collect();
|
||||
let mut row: Vec<usize> = (0..=b.len()).collect();
|
||||
for (i, ca) in a.chars().enumerate() {
|
||||
let mut diagonal = row[0];
|
||||
row[0] = i + 1;
|
||||
for (j, cb) in b.iter().enumerate() {
|
||||
let next = (row[j + 1] + 1).min(row[j] + 1).min(diagonal + usize::from(ca != *cb));
|
||||
diagonal = row[j + 1];
|
||||
row[j + 1] = next;
|
||||
}
|
||||
}
|
||||
row[b.len()]
|
||||
}
|
||||
|
||||
fn capitalize(s: &str) -> String {
|
||||
let mut chars = s.chars();
|
||||
chars.next().into_iter().flat_map(char::to_uppercase).chain(chars).collect()
|
||||
@@ -801,36 +736,6 @@ mod tests {
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hunspell_custom_dictionaries_use_their_affix_rules() {
|
||||
let dir = std::env::temp_dir().join(format!("ide-spell-hunspell-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let dic = dir.join("de_TEST.dic");
|
||||
std::fs::write(&dic, "3\nhaus/NZ\ntür/NZ\nschlüssel/Z\n").unwrap();
|
||||
std::fs::write(
|
||||
dir.join("de_TEST.aff"),
|
||||
"SET UTF-8\nTRY esianrtolcdugmphbyfvkwzäöüß\nCOMPOUNDFLAG Z\nSFX N Y 1\nSFX N 0 en .\n",
|
||||
)
|
||||
.unwrap();
|
||||
let s = Speller::new::<&str>([], std::slice::from_ref(&dic));
|
||||
// Affix rules, compounds and case styles of the .aff, not just the listed stems.
|
||||
for word in ["haus", "Haus", "hausen", "türen", "Haustür", "schlüsselhaus"] {
|
||||
assert!(s.is_correct(word), "{word}");
|
||||
}
|
||||
assert!(!s.is_correct("hauz"));
|
||||
assert!(!s.is_correct("schlüsselen"));
|
||||
assert!(s.suggest("Hauss", 5).iter().any(|w| w == "Haus"), "{:?}", s.suggest("Hauss", 5));
|
||||
// English still checks and suggests.
|
||||
assert!(s.is_correct("message"));
|
||||
assert!(s.suggest("mesage", 5).iter().any(|w| w == "message"));
|
||||
// Without its .aff, a .dic is a word list.
|
||||
std::fs::remove_file(dir.join("de_TEST.aff")).unwrap();
|
||||
let words = Speller::new::<&str>([], std::slice::from_ref(&dic));
|
||||
assert!(words.is_correct("haus"));
|
||||
assert!(!words.is_correct("hausen"));
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn utf16_ranges() {
|
||||
let s = Speller::default();
|
||||
|
||||
@@ -372,8 +372,6 @@ fn materialize_row(
|
||||
if let Some((pos, total)) = position {
|
||||
commit.log_position = Some(pos);
|
||||
commit.log_total = Some(total);
|
||||
let merge_time_ms = row.merge_time_secs as f64 * 1000.0;
|
||||
commit.log_merge_time_ms = (merge_time_ms > commit.commit_time_ms).then_some(merge_time_ms);
|
||||
}
|
||||
if !summary_only {
|
||||
commit.message = index.message(repo, row.id)?;
|
||||
@@ -716,16 +714,17 @@ fn log_indexed_rows(
|
||||
skip -= 1;
|
||||
continue;
|
||||
}
|
||||
let (parents, commit_time_secs) = if let Some((parents, time)) = visibility.index.nodes.get(&id) {
|
||||
(parents.clone(), *time)
|
||||
let parents: Vec<ObjectId> = if shallow.contains(&id) {
|
||||
Vec::new()
|
||||
} else if let Some((ps, _)) = visibility.index.nodes.get(&id) {
|
||||
ps.clone()
|
||||
} else {
|
||||
let record = visibility.index.get_with_table(&repo, id, visibility.table)?;
|
||||
let parents = record
|
||||
record
|
||||
.parents
|
||||
.iter()
|
||||
.map(|p| ObjectId::from_hex(p.as_bytes()).map_err(gx))
|
||||
.collect::<IdeResult<Vec<_>>>()?;
|
||||
(parents, (record.commit_time_ms / 1000.0) as i64)
|
||||
.collect::<IdeResult<Vec<_>>>()?
|
||||
};
|
||||
let shown_parents = if shallow.contains(&id) {
|
||||
Vec::new()
|
||||
@@ -744,7 +743,6 @@ fn log_indexed_rows(
|
||||
graph_parents: shown_parents,
|
||||
on_current_branch,
|
||||
history_path: history_paths.get(&id).cloned(),
|
||||
merge_time_secs: commit_time_secs,
|
||||
});
|
||||
if out.len() >= limit || stop_id == Some(id) {
|
||||
break;
|
||||
|
||||
@@ -125,9 +125,6 @@ pub struct Commit {
|
||||
pub log_position: Option<u32>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub log_total: Option<u32>,
|
||||
/// Newest committer time at or after this row if newer than the row's commit.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub log_merge_time_ms: Option<f64>,
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub graph_boundary_parents: Vec<String>,
|
||||
/// Reachability from HEAD, computed independently of the visible filters.
|
||||
|
||||
@@ -19,16 +19,12 @@ const MESSAGES: TableDefinition<&str, &str> = TableDefinition::new("messages-v1"
|
||||
const MAX_MEMORY_COMMITS: usize = 4096;
|
||||
const MAX_MEMORY_MESSAGES: usize = 1024;
|
||||
const MAX_DIRTY_BATCH: usize = 16_384;
|
||||
/// redb's page cache, which otherwise grows to 1 GiB per repository. Hot commits are already
|
||||
/// kept in `memory`.
|
||||
const DB_CACHE_BYTES: usize = 32 * 1024 * 1024;
|
||||
|
||||
pub(crate) struct IndexedRow {
|
||||
pub id: ObjectId,
|
||||
pub graph_parents: Vec<ObjectId>,
|
||||
pub on_current_branch: bool,
|
||||
pub history_path: Option<String>,
|
||||
pub merge_time_secs: i64,
|
||||
}
|
||||
|
||||
pub(crate) struct IndexedView {
|
||||
@@ -36,15 +32,8 @@ pub(crate) struct IndexedView {
|
||||
pub positions: HashMap<ObjectId, usize>,
|
||||
}
|
||||
impl IndexedView {
|
||||
pub fn new(mut rows: Vec<IndexedRow>) -> Self {
|
||||
let mut positions = HashMap::with_capacity(rows.len());
|
||||
let mut latest = i64::MIN;
|
||||
// Compute priority across the whole log so it stays the same on every page.
|
||||
for (i, row) in rows.iter_mut().enumerate().rev() {
|
||||
latest = latest.max(row.merge_time_secs);
|
||||
row.merge_time_secs = latest;
|
||||
positions.insert(row.id, i);
|
||||
}
|
||||
pub fn new(rows: Vec<IndexedRow>) -> Self {
|
||||
let positions = rows.iter().enumerate().map(|(i, r)| (r.id, i)).collect();
|
||||
Self { rows, positions }
|
||||
}
|
||||
}
|
||||
@@ -280,11 +269,7 @@ impl LogIndex {
|
||||
let path = dir.join("commits.redb");
|
||||
let mut databases = DATABASES.get_or_init(Mutex::default).lock().unwrap_or_else(|p| p.into_inner());
|
||||
self.db = databases.get(&path).and_then(Weak::upgrade).or_else(|| {
|
||||
let db = Arc::new(
|
||||
std::fs::create_dir_all(dir)
|
||||
.ok()
|
||||
.and_then(|_| Database::builder().set_cache_size(DB_CACHE_BYTES).create(&path).ok())?,
|
||||
);
|
||||
let db = Arc::new(std::fs::create_dir_all(dir).ok().and_then(|_| Database::create(&path).ok())?);
|
||||
drop_stale_tables(&db);
|
||||
databases.insert(path, Arc::downgrade(&db));
|
||||
Some(db)
|
||||
@@ -349,7 +334,6 @@ impl LogIndex {
|
||||
history_path: None,
|
||||
log_position: None,
|
||||
log_total: None,
|
||||
log_merge_time_ms: None,
|
||||
graph_boundary_parents: Vec::new(),
|
||||
refs: Vec::new(),
|
||||
});
|
||||
|
||||
@@ -235,12 +235,6 @@ fn gix_status(r: &Repo, ignored: &IgnoredNames) -> IdeResult<Entries> {
|
||||
Ok((map, conflicts))
|
||||
}
|
||||
|
||||
/// Keeps `git status` from rewriting the index with refreshed stat data. Such a write is not
|
||||
/// one of ours to the watcher, so it would schedule another refresh, which runs git again (#4792).
|
||||
fn read_only() -> [(&'static str, &'static std::ffi::OsStr); 1] {
|
||||
[("GIT_OPTIONAL_LOCKS", std::ffi::OsStr::new("0"))]
|
||||
}
|
||||
|
||||
/// `git status --porcelain=v2`: what git lists, unreadable directories skipped.
|
||||
/// In Restricted Mode git compares content without the repository's clean/process
|
||||
/// filters and doesn't ask submodules for their own status (which runs their config).
|
||||
@@ -251,7 +245,7 @@ fn cli_status(r: &Repo, ignored: &IgnoredNames) -> IdeResult<Entries> {
|
||||
if !crate::execution_allowed() {
|
||||
args.push("--ignore-submodules=dirty");
|
||||
}
|
||||
let out = crate::cli::run_env(r.root(), &args, None, &read_only())?;
|
||||
let out = crate::cli::run(r.root(), &args, None)?;
|
||||
Ok(parse_porcelain_v2(&String::from_utf8_lossy(&out.stdout), ignored))
|
||||
}
|
||||
|
||||
@@ -266,7 +260,7 @@ fn cli_status_paths(r: &Repo, ignored: &IgnoredNames, paths: &[String]) -> IdeRe
|
||||
}
|
||||
args.push("--");
|
||||
args.extend(paths.iter().map(String::as_str));
|
||||
let out = crate::cli::run_env(r.root(), &args, None, &read_only())?;
|
||||
let out = crate::cli::run(r.root(), &args, None)?;
|
||||
Ok(parse_porcelain_v2(&String::from_utf8_lossy(&out.stdout), ignored))
|
||||
}
|
||||
|
||||
@@ -403,29 +397,6 @@ mod tests {
|
||||
assert!(staged.stdout.is_empty(), "{}", String::from_utf8_lossy(&staged.stdout));
|
||||
}
|
||||
|
||||
/// #4792: the dirty-scope `git status` must not rewrite the index after refreshing stale
|
||||
/// stat data, or the watcher sees a foreign index write and refreshes again.
|
||||
#[test]
|
||||
fn git_status_of_paths_leaves_the_index_alone() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let dir = tmp.path();
|
||||
git(dir, &["init", "-q"]);
|
||||
git(dir, &["config", "user.name", "Test User"]);
|
||||
git(dir, &["config", "user.email", "[email protected]"]);
|
||||
git(dir, &["config", "commit.gpgsign", "false"]);
|
||||
std::fs::write(dir.join("a.txt"), "a\n").unwrap();
|
||||
commit_all(dir, "base");
|
||||
// Same content, new stat data: plain `git status` would refresh and write the index.
|
||||
std::thread::sleep(std::time::Duration::from_millis(1100));
|
||||
std::fs::write(dir.join("a.txt"), "a\n").unwrap();
|
||||
let index = dir.join(".git/index");
|
||||
let before = std::fs::read(&index).unwrap();
|
||||
|
||||
let repo = Repo::discover(dir).unwrap().expect("repository found");
|
||||
assert!(status_paths(&repo, &["a.txt".to_owned()]).unwrap().is_empty());
|
||||
assert_eq!(std::fs::read(&index).unwrap(), before, "git status rewrote the index");
|
||||
}
|
||||
|
||||
/// git's porcelain answer (used when gitoxide can't read the tree) matches gitoxide's.
|
||||
#[test]
|
||||
fn git_and_gitoxide_report_the_same_status() {
|
||||
|
||||
@@ -1155,31 +1155,16 @@ fn check_rev(rev: &str) -> IdeResult<&str> {
|
||||
Ok(rev)
|
||||
}
|
||||
|
||||
/// The short name of a full branch ref (`refs/heads/x`, `refs/remotes/origin/x`) when it
|
||||
/// names that same branch: git writes the name it is given into the merge message and the
|
||||
/// reflog. A name a tag shares stays a full ref, the case IDEA also passes in full.
|
||||
fn unambiguous_branch_name<'a>(r: &Repo, rev: &'a str) -> &'a str {
|
||||
let Some(short) = rev.strip_prefix("refs/heads/").or_else(|| rev.strip_prefix("refs/remotes/")) else {
|
||||
return rev;
|
||||
};
|
||||
// An ambiguous name prints nothing (git reports it on stderr).
|
||||
let full = cli::run_raw(r.root(), &["rev-parse", "--verify", "-q", "--symbolic-full-name", short], None);
|
||||
match full {
|
||||
Ok(out) if out.code == Some(0) && out.stdout_str().trim() == rev => short,
|
||||
_ => rev,
|
||||
}
|
||||
}
|
||||
|
||||
/// Local changes are stashed and restored around the merge (IDEA's "save local changes").
|
||||
pub(crate) fn merge(r: &Repo, branch: &str) -> IdeResult<()> {
|
||||
let branch = unambiguous_branch_name(r, check_rev(branch)?);
|
||||
let branch = check_rev(branch)?;
|
||||
crate::preserve::around(r, "Local changes saved before merge", || {
|
||||
run(r.root(), &["merge", "--no-edit", branch], None).map(|_| ())
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn rebase(r: &Repo, onto: &str) -> IdeResult<()> {
|
||||
let onto = unambiguous_branch_name(r, check_rev(onto)?);
|
||||
let onto = check_rev(onto)?;
|
||||
crate::preserve::around(r, "Local changes saved before rebase", || {
|
||||
run(r.root(), &["rebase", onto], None).map(|_| ())
|
||||
})
|
||||
|
||||
@@ -505,37 +505,6 @@ fn rebase_and_merge_onto_a_branch_named_like_a_tag_use_the_branch() {
|
||||
assert_eq!(fx.head(), tip, "fast-forwarded to the branch, not the tag");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn merge_and_rebase_record_the_branch_name_git_would_show() {
|
||||
let (fx, _bare) = Fixture::with_origin();
|
||||
fx.git(&["switch", "-q", "-c", "topic"]);
|
||||
fx.write("t.txt", "t\n");
|
||||
fx.commit_all("topic");
|
||||
fx.git(&["push", "-q", "origin", "topic"]);
|
||||
fx.git(&["switch", "-q", "main"]);
|
||||
fx.write("m.txt", "m\n");
|
||||
fx.commit_all("main");
|
||||
let repo = fx.repo();
|
||||
let subject = || fx.git(&["log", "-1", "--format=%s"]);
|
||||
|
||||
repo.merge("refs/heads/topic").unwrap();
|
||||
assert_eq!(subject(), "Merge branch 'topic'");
|
||||
fx.git(&["reset", "-q", "--hard", "HEAD~1"]);
|
||||
repo.merge("refs/remotes/origin/topic").unwrap();
|
||||
assert_eq!(subject(), "Merge remote-tracking branch 'origin/topic'");
|
||||
fx.git(&["reset", "-q", "--hard", "HEAD~1"]);
|
||||
|
||||
repo.rebase("refs/heads/topic").unwrap();
|
||||
let reflog = fx.git(&["reflog", "--format=%gs"]);
|
||||
assert!(reflog.contains("rebase (start): checkout topic"), "{reflog}");
|
||||
fx.git(&["reset", "-q", "--hard", "ORIG_HEAD"]);
|
||||
|
||||
// A tag of the same name makes the short name ambiguous: the full ref stays.
|
||||
fx.git(&["tag", "topic", "main~1"]);
|
||||
repo.merge("refs/heads/topic").unwrap();
|
||||
assert_eq!(subject(), "Merge branch 'refs/heads/topic'");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn interactive_rebase_edit_stops_for_amend() {
|
||||
let (fx, ids) = linear();
|
||||
|
||||
@@ -83,28 +83,6 @@ fn incoming_order_groups_the_merged_branch_before_the_main_parent() {
|
||||
assert_eq!(out[1].parents, vec![h.c2.clone(), h.s1.clone()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_older_incoming_tip_uses_the_later_commit_time_when_merging_repo_pages() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let dir = tmp.path();
|
||||
git(dir, &["init", "-q"], None);
|
||||
let base = commit(dir, "base.txt", "base", 1000);
|
||||
let recent = commit(dir, "recent.txt", "recent", 4000);
|
||||
git(dir, &["checkout", "-qb", "incoming", &base], None);
|
||||
let incoming = commit(dir, "incoming.txt", "incoming", 2000);
|
||||
git(dir, &["checkout", "-q", "main"], None);
|
||||
let repo = Repo::discover(dir).unwrap().unwrap();
|
||||
let query = LogQuery { summary_only: true, order: LogOrder::Standard, limit: 1, ..Default::default() };
|
||||
|
||||
let first = repo.log(&query).unwrap();
|
||||
assert_eq!(first[0].id, incoming);
|
||||
assert_eq!(first[0].commit_time_ms, 2_000_000.0);
|
||||
assert_eq!(first[0].log_merge_time_ms, Some(4_000_000.0));
|
||||
let next = repo.log(&LogQuery { skip: 1, ..query }).unwrap();
|
||||
assert_eq!(next[0].id, recent);
|
||||
assert_eq!(next[0].log_merge_time_ms, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_merges_links_children_to_the_merge_parents() {
|
||||
let h = history();
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
use crate::editorconfig::{EditorConfig, EditorConfigProps};
|
||||
use crate::file_defaults::FileDefaults;
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::event::NotifyLevel;
|
||||
use ide_core::{ChangeSet, DocId, IdeError, IdeEvent, IdeResult, LanguageId, SharedSink, TextEdit};
|
||||
use ide_text::{AppliedChange, ByteEdit, Document, LineEnding};
|
||||
use parking_lot::{Mutex, ReentrantMutex, RwLock};
|
||||
@@ -1137,24 +1138,6 @@ impl Documents {
|
||||
})
|
||||
}
|
||||
|
||||
/// Load Changes from Disk: drops the buffer's unsaved changes and reads its file again in
|
||||
/// the buffer's encoding, after the file changed on disk (`IdeEvent::DocDiskConflict`).
|
||||
pub fn discard_and_reload(&self, doc: DocId) -> IdeResult<()> {
|
||||
self.with_doc(doc, |st| {
|
||||
if st.uri.is_some() || st.binary {
|
||||
return Err(IdeError::invalid("only a file's text can be reloaded from disk"));
|
||||
}
|
||||
let loaded = Self::load_as(&st.path, &st.encoding, st.native_to_ascii)?;
|
||||
st.has_bom = loaded.has_bom;
|
||||
st.disk_mtime = loaded.mtime_ms;
|
||||
st.disk_len = disk_len(&st.path);
|
||||
st.disk_conflict = false;
|
||||
self.replace_locked(doc, st, &loaded.text)?;
|
||||
self.set_dirty(doc, st, false);
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
/// The URI of a virtual document, or `None` for a file-backed one.
|
||||
pub fn virtual_uri(&self, doc: DocId) -> IdeResult<Option<String>> {
|
||||
self.with_doc(doc, |st| Ok(st.uri.clone()))
|
||||
@@ -1267,7 +1250,7 @@ impl Documents {
|
||||
}
|
||||
|
||||
/// Re-reads from disk after an external change. Clean documents reload
|
||||
/// silently; dirty ones are left alone and reported via `IdeEvent::DocDiskConflict`.
|
||||
/// silently; dirty ones are left alone and reported via `IdeEvent::Notify`.
|
||||
/// Changes matching our own last save are ignored.
|
||||
pub fn on_disk_changed(&self, paths: &[PathBuf]) {
|
||||
self.reload_from_disk(paths, false, false);
|
||||
@@ -1306,7 +1289,16 @@ impl Documents {
|
||||
st.disk_mtime = mtime;
|
||||
st.disk_len = meta.len();
|
||||
st.disk_conflict = true;
|
||||
self.sink.emit(IdeEvent::DocDiskConflict { doc: id, path: st.path.to_string_lossy().into_owned() });
|
||||
let name = st.path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
|
||||
self.sink.emit(IdeEvent::Notify {
|
||||
level: NotifyLevel::Warning,
|
||||
title: format!("{name} changed on disk"),
|
||||
body: Some(format!(
|
||||
"{} was modified externally but has unsaved changes in the editor. \
|
||||
Saving explicitly will overwrite the external changes; autosave leaves the file alone.",
|
||||
st.path.display()
|
||||
)),
|
||||
});
|
||||
return Ok(());
|
||||
}
|
||||
let loaded = if force_clean {
|
||||
|
||||
@@ -422,8 +422,6 @@ impl Documents {
|
||||
}
|
||||
// Validate project rules before path resolution can erase linked components.
|
||||
crate::file_ops::validate_workspace_edit_paths(edit)?;
|
||||
// Editors know the paths as the edit named them, before link resolution.
|
||||
let moves = edit.moves();
|
||||
let mut edit = normalize_edit(edit)?;
|
||||
let captured = !edit.preconditions.is_empty();
|
||||
crate::file_ops::expand_workspace_edit(&mut edit)?;
|
||||
@@ -503,7 +501,7 @@ impl Documents {
|
||||
});
|
||||
}
|
||||
history.prune(SystemTime::now(), MAX_HISTORY_BYTES, MAX_HISTORY_AGE);
|
||||
self.sink.emit(IdeEvent::WorkspaceEditApplied { id, paths: affected, moves, by_agent });
|
||||
self.sink.emit(IdeEvent::WorkspaceEditApplied { id, paths: affected, by_agent });
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
Loaded 100 of 566 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача